diff --git a/gfx/cairo/cairo/INSTALL b/gfx/cairo/cairo/INSTALL
--- a/gfx/cairo/cairo/INSTALL
+++ b/gfx/cairo/cairo/INSTALL
@@ -158,17 +158,17 @@ order to compile cairo. Specifically, yo
 
 	automake (1.8 or newer)
 	autoconf
 	libtool
 
 Hopefully your platform of choice has packages readily available so
 that you can easily install things with your system's package
 management tool, (such as "apt-get install automake" on Debian or "yum
-install automake" on Fedora, etc.). Note that Mac OS X ships with it's
+install automake" on Fedora, etc.). Note that Mac OS X ships with its
 own utility called libtool which is not what you want, (the one you do
 want goes by the name of glibtool).
 
 Once you have all of those packages installed, the next step is to run
 the autogen.sh script. That can be as simple as:
 
 	./autogen.sh
 
diff --git a/gfx/cairo/cairo/src/cairo-ft-font.c b/gfx/cairo/cairo/src/cairo-ft-font.c
--- a/gfx/cairo/cairo/src/cairo-ft-font.c
+++ b/gfx/cairo/cairo/src/cairo-ft-font.c
@@ -2635,17 +2635,17 @@ cairo_ft_font_face_create_for_ft_face (F
  * kept of the number of times cairo_ft_scaled_font_lock_face() is
  * called. cairo_ft_scaled_font_unlock_face() must be called the same number
  * of times.
  *
  * You must be careful when using this function in a library or in a
  * threaded application, because freetype's design makes it unsafe to
  * call freetype functions simultaneously from multiple threads, (even
  * if using distinct FT_Face objects). Because of this, application
- * code that acquires an FT_Face object with this call must add it's
+ * code that acquires an FT_Face object with this call must add its
  * own locking to protect any use of that object, (and which also must
  * protect any other calls into cairo as almost any cairo function
  * might result in a call into the freetype library).
  *
  * Return value: The #FT_Face object for @font, scaled appropriately,
  * or %NULL if @scaled_font is in an error state (see
  * cairo_scaled_font_status()) or there is insufficient memory.
  **/
diff --git a/gfx/cairo/cairo/src/cairo-matrix.c b/gfx/cairo/cairo/src/cairo-matrix.c
--- a/gfx/cairo/cairo/src/cairo-matrix.c
+++ b/gfx/cairo/cairo/src/cairo-matrix.c
@@ -468,17 +468,17 @@ _cairo_matrix_compute_adjoint (cairo_mat
 		       -c, a,
 		       c*ty - d*tx, b*tx - a*ty);
 }
 
 /**
  * cairo_matrix_invert:
  * @matrix: a #cairo_matrix_t
  *
- * Changes @matrix to be the inverse of it's original value. Not
+ * Changes @matrix to be the inverse of its original value. Not
  * all transformation matrices have inverses; if the matrix
  * collapses points together (it is <firstterm>degenerate</firstterm>),
  * then it has no inverse and this function will fail.
  *
  * Returns: If @matrix has an inverse, modifies @matrix to
  *  be the inverse matrix and returns %CAIRO_STATUS_SUCCESS. Otherwise,
  *  returns %CAIRO_STATUS_INVALID_MATRIX.
  **/
diff --git a/gfx/cairo/cairo/src/cairo-mutex-impl-private.h b/gfx/cairo/cairo/src/cairo-mutex-impl-private.h
--- a/gfx/cairo/cairo/src/cairo-mutex-impl-private.h
+++ b/gfx/cairo/cairo/src/cairo-mutex-impl-private.h
@@ -48,17 +48,17 @@
 #endif
 
 #if HAVE_LOCKDEP
 #include <lockdep.h>
 #endif
 
 /* A fully qualified no-operation statement */
 #define CAIRO_MUTEX_IMPL_NOOP	do {/*no-op*/} while (0)
-/* And one that evaluates it's argument once */
+/* And one that evaluates its argument once */
 #define CAIRO_MUTEX_IMPL_NOOP1(expr)        do { if (expr) ; } while (0)
 
 
 /* Cairo mutex implementation:
  *
  * Any new mutex implementation needs to do the following:
  *
  * - Condition on the right header or feature.  Headers are
diff --git a/gfx/cairo/cairo/src/cairo-pdf-operators.c b/gfx/cairo/cairo/src/cairo-pdf-operators.c
--- a/gfx/cairo/cairo/src/cairo-pdf-operators.c
+++ b/gfx/cairo/cairo/src/cairo-pdf-operators.c
@@ -107,17 +107,17 @@ _cairo_pdf_operators_set_cairo_to_pdf_ma
 
 /* Finish writing out any pending commands to the stream. This
  * function must be called by the surface before emitting anything
  * into the PDF stream.
  *
  * pdf_operators may leave the emitted PDF for some operations
  * unfinished in case subsequent operations can be merged. This
  * function will finish off any incomplete operation so the stream
- * will be in a state where the surface may emit it's own PDF
+ * will be in a state where the surface may emit its own PDF
  * operations (eg changing patterns).
  *
  */
 cairo_status_t
 _cairo_pdf_operators_flush (cairo_pdf_operators_t	 *pdf_operators)
 {
     cairo_status_t status = CAIRO_STATUS_SUCCESS;
 
diff --git a/gfx/cairo/cairo/src/cairo-surface-fallback.c b/gfx/cairo/cairo/src/cairo-surface-fallback.c
--- a/gfx/cairo/cairo/src/cairo-surface-fallback.c
+++ b/gfx/cairo/cairo/src/cairo-surface-fallback.c
@@ -627,17 +627,17 @@ _clip_and_composite_trapezoids (cairo_pa
             /* For a simple rectangle, we can just use composite(), for more
              * rectangles, we have to set a clip region. The cost of rasterizing
              * trapezoids is pretty high for most backends currently, so it's
              * worthwhile even if a region is needed.
              *
              * If we have a clip surface, we set it as the mask; this only works
              * for bounded operators other than SOURCE; for unbounded operators,
              * clip and mask cannot be interchanged. For SOURCE, the operator
-             * as implemented by the backends is different in it's handling
+             * as implemented by the backends is different in its handling
              * of the mask then what we want.
              *
              * CAIRO_INT_STATUS_UNSUPPORTED will be returned if the region has
              * more than rectangle and the destination doesn't support clip
              * regions. In that case, we fall through.
              */
             status = _composite_trap_region (clip, src, op, dst,
                                              &trap_region, &extents);