diff --git a/include/c/sk_canvas.h b/include/c/sk_canvas.h
index 559ef95..9eb21f3 100644
--- a/include/c/sk_canvas.h
+++ b/include/c/sk_canvas.h
@@ -24,14 +24,19 @@
 void sk_canvas_rotate_degrees(sk_canvas_t*, float degrees);
 void sk_canvas_rotate_radians(sk_canvas_t*, float radians);
 void sk_canvas_skew(sk_canvas_t*, float sx, float sy);
+void sk_canvas_concat(sk_canvas_t*, const sk_matrix_t*);
 
-void sk_canvas_concat_matrix(sk_canvas_t*, const sk_matrix_t*);
+void sk_canvas_clip_rect(sk_canvas_t*, const sk_rect_t*);
+void sk_canvas_clip_path(sk_canvas_t*, const sk_path_t*);
 
 void sk_canvas_draw_paint(sk_canvas_t*, const sk_paint_t*);
 void sk_canvas_draw_rect(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*);
 void sk_canvas_draw_oval(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*);
 void sk_canvas_draw_path(sk_canvas_t*, const sk_path_t*, const sk_paint_t*);
 void sk_canvas_draw_image(sk_canvas_t*, const sk_image_t*, float x, float y, const sk_paint_t*);
+void sk_canvas_draw_image_rect(sk_canvas_t*, const sk_image_t*, const sk_rect_t* src,
+                               const sk_rect_t* dst, const sk_paint_t*);
+void sk_canvas_draw_picture(sk_canvas_t*, const sk_picture_t*, const sk_matrix_t*, const sk_paint_t*);
 
 SK_C_PLUS_PLUS_END_GUARD
 
diff --git a/include/c/sk_picture.h b/include/c/sk_picture.h
new file mode 100644
index 0000000..f062d32
--- /dev/null
+++ b/include/c/sk_picture.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL
+// DO NOT USE -- FOR INTERNAL TESTING ONLY
+
+#ifndef sk_picture_DEFINED
+#define sk_picture_DEFINED
+
+#include "sk_types.h"
+
+SK_C_PLUS_PLUS_BEGIN_GUARD
+
+sk_picture_recorder_t* sk_picture_recorder_new();
+void sk_picture_recorder_delete(sk_picture_recorder_t*);
+
+sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t*, const sk_rect_t*);
+sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t*);
+
+void sk_picture_ref(sk_picture_t*);
+void sk_picture_unref(sk_picture_t*);
+
+uint32_t sk_picture_get_unique_id(sk_picture_t*);
+sk_rect_t sk_picture_get_bounds(sk_picture_t*);
+
+SK_C_PLUS_PLUS_END_GUARD
+
+#endif
diff --git a/include/c/sk_types.h b/include/c/sk_types.h
index 4c63896..f5f4b57 100644
--- a/include/c/sk_types.h
+++ b/include/c/sk_types.h
@@ -48,6 +48,11 @@
     UNPREMUL_SK_ALPHATYPE,
 } sk_alphatype_t;
 
+typedef enum {
+    INTERSECT_SK_CLIPTYPE,
+    DIFFERENCE_SK_CLIPTYPE,
+} sk_cliptype_t;
+
 sk_colortype_t sk_colortype_get_default_8888();
 
 typedef struct {
@@ -76,6 +81,8 @@
 typedef struct sk_canvas_t sk_canvas_t;
 typedef struct sk_image_t sk_image_t;
 typedef struct sk_paint_t sk_paint_t;
+typedef struct sk_picture_t sk_picture_t;
+typedef struct sk_picture_recorder_t sk_picture_recorder_t;
 typedef struct sk_path_t sk_path_t;
 typedef struct sk_shader_t sk_shader_t;
 typedef struct sk_surface_t sk_surface_t;
diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp
index 94e925a..0a94002 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -16,6 +16,7 @@
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkPath.h"
+#include "SkPictureRecorder.h"
 #include "SkSurface.h"
 
 const struct {
@@ -117,12 +118,16 @@
     return false;
 }
 
+static sk_rect_t ToRect(const SkRect& rect) {
+    return reinterpret_cast<const sk_rect_t&>(rect);
+}
+
 static const SkRect& AsRect(const sk_rect_t& crect) {
     return reinterpret_cast<const SkRect&>(crect);
 }
 
-static SkRect* as_rect(sk_rect_t* crect) {
-    return reinterpret_cast<SkRect*>(crect);
+static const SkRect* AsRect(const sk_rect_t* crect) {
+    return reinterpret_cast<const SkRect*>(crect);
 }
 
 static const SkPath& AsPath(const sk_path_t& cpath) {
@@ -149,6 +154,10 @@
     return reinterpret_cast<SkPaint*>(cpaint);
 }
 
+static sk_canvas_t* ToCanvas(SkCanvas* canvas) {
+    return reinterpret_cast<sk_canvas_t*>(canvas);
+}
+
 static SkCanvas* AsCanvas(sk_canvas_t* ccanvas) {
     return reinterpret_cast<SkCanvas*>(ccanvas);
 }
@@ -157,6 +166,26 @@
     return reinterpret_cast<SkShader*>(cshader);
 }
 
+static SkPictureRecorder* AsPictureRecorder(sk_picture_recorder_t* crec) {
+    return reinterpret_cast<SkPictureRecorder*>(crec);
+}
+
+static sk_picture_recorder_t* ToPictureRecorder(SkPictureRecorder* rec) {
+    return reinterpret_cast<sk_picture_recorder_t*>(rec);
+}
+
+static const SkPicture* AsPicture(const sk_picture_t* cpic) {
+    return reinterpret_cast<const SkPicture*>(cpic);
+}
+
+static SkPicture* AsPicture(sk_picture_t* cpic) {
+    return reinterpret_cast<SkPicture*>(cpic);
+}
+
+static sk_picture_t* ToPicture(SkPicture* pic) {
+    return reinterpret_cast<sk_picture_t*>(pic);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 sk_colortype_t sk_colortype_get_default_8888() {
@@ -280,15 +309,17 @@
 
 bool sk_path_get_bounds(const sk_path_t* cpath, sk_rect_t* crect) {
     const SkPath& path = AsPath(*cpath);
-    SkRect* rect = as_rect(crect);
 
     if (path.isEmpty()) {
-        if (rect) {
-            rect->setEmpty();
+        if (crect) {
+            *crect = ToRect(SkRect::MakeEmpty());
         }
         return false;
     }
-    *rect = path.getBounds();
+
+    if (crect) {
+        *crect = ToRect(path.getBounds());
+    }
     return true;
 }
 
@@ -326,13 +357,21 @@
     AsCanvas(ccanvas)->skew(sx, sy);
 }
 
-void sk_canvas_concat_matrix(sk_canvas_t* ccanvas, const sk_matrix_t* cmatrix) {
+void sk_canvas_concat(sk_canvas_t* ccanvas, const sk_matrix_t* cmatrix) {
     SkASSERT(cmatrix);
     SkMatrix matrix;
     from_c_matrix(cmatrix, &matrix);
     AsCanvas(ccanvas)->concat(matrix);
 }
 
+void sk_canvas_clip_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect) {
+    AsCanvas(ccanvas)->clipRect(AsRect(*crect));
+}
+
+void sk_canvas_clip_path(sk_canvas_t* ccanvas, const sk_path_t* cpath) {
+    AsCanvas(ccanvas)->clipPath(AsPath(*cpath));
+}
+
 void sk_canvas_draw_paint(sk_canvas_t* ccanvas, const sk_paint_t* cpaint) {
     AsCanvas(ccanvas)->drawPaint(AsPaint(*cpaint));
 }
@@ -354,6 +393,23 @@
     AsCanvas(ccanvas)->drawImage(AsImage(cimage), x, y, AsPaint(cpaint));
 }
 
+void sk_canvas_draw_image_rect(sk_canvas_t* ccanvas, const sk_image_t* cimage,
+                               const sk_rect_t* csrcR, const sk_rect_t* cdstR,
+                               const sk_paint_t* cpaint) {
+    AsCanvas(ccanvas)->drawImageRect(AsImage(cimage), AsRect(csrcR), AsRect(*cdstR), AsPaint(cpaint));
+}
+
+void sk_canvas_draw_picture(sk_canvas_t* ccanvas, const sk_picture_t* cpicture,
+                            const sk_matrix_t* cmatrix, const sk_paint_t* cpaint) {
+    const SkMatrix* matrixPtr = NULL;
+    SkMatrix matrix;
+    if (cmatrix) {
+        from_c_matrix(cmatrix, &matrix);
+        matrixPtr = &matrix;
+    }
+    AsCanvas(ccanvas)->drawPicture(AsPicture(cpicture), matrixPtr, AsPaint(cpaint));
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 sk_surface_t* sk_surface_new_raster(const sk_imageinfo_t* cinfo) {
@@ -389,6 +445,41 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
+sk_picture_recorder_t* sk_picture_recorder_new() {
+    return ToPictureRecorder(new SkPictureRecorder);
+}
+
+void sk_picture_recorder_delete(sk_picture_recorder_t* crec) {
+    delete AsPictureRecorder(crec);
+}
+
+sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t* crec,
+                                                 const sk_rect_t* cbounds) {
+    return ToCanvas(AsPictureRecorder(crec)->beginRecording(AsRect(*cbounds)));
+}
+
+sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t* crec) {
+    return ToPicture(AsPictureRecorder(crec)->endRecording());
+}
+
+void sk_picture_ref(sk_picture_t* cpic) {
+    SkSafeRef(AsPicture(cpic));
+}
+
+void sk_picture_unref(sk_picture_t* cpic) {
+    SkSafeUnref(AsPicture(cpic));
+}
+
+uint32_t sk_picture_get_unique_id(sk_picture_t* cpic) {
+    return AsPicture(cpic)->uniqueID();
+}
+
+sk_rect_t sk_picture_get_bounds(sk_picture_t* cpic) {
+    return ToRect(AsPicture(cpic)->cullRect());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
 #include "../../include/effects/SkGradientShader.h"
 #include "sk_shader.h"