diff --git a/gm/image.cpp b/gm/image.cpp
index 974f5f9..8578e51 100644
--- a/gm/image.cpp
+++ b/gm/image.cpp
@@ -64,16 +64,16 @@
 
 static void test_surface(SkCanvas* canvas, SkSurface* surf) {
     drawContents(surf, SK_ColorRED);
-    SkImage* imgR = surf->newImageShapshot();
+    SkImage* imgR = surf->newImageSnapshot();
 
     if (true) {
-        SkImage* imgR2 = surf->newImageShapshot();
+        SkImage* imgR2 = surf->newImageSnapshot();
         SkASSERT(imgR == imgR2);
         imgR2->unref();
     }
 
     drawContents(surf, SK_ColorGREEN);
-    SkImage* imgG = surf->newImageShapshot();
+    SkImage* imgG = surf->newImageSnapshot();
 
     // since we've drawn after we snapped imgR, imgG will be a different obj
     SkASSERT(imgR != imgG);
diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h
index 7001299..4a38029 100644
--- a/include/core/SkSurface.h
+++ b/include/core/SkSurface.h
@@ -112,7 +112,7 @@
      *  point. Subsequent changes to the surface (by drawing into its canvas)
      *  will not be reflected in this image.
      */
-    SkImage* newImageShapshot();
+    SkImage* newImageSnapshot();
 
     /**
      *  Thought the caller could get a snapshot image explicitly, and draw that,
diff --git a/include/utils/SkDeferredCanvas.h b/include/utils/SkDeferredCanvas.h
index 97b4a66..60f709c 100644
--- a/include/utils/SkDeferredCanvas.h
+++ b/include/utils/SkDeferredCanvas.h
@@ -107,7 +107,7 @@
      *  reflected in this image.  Will return NULL if the deferred canvas
      *  was not constructed from an SkSurface.
      */
-    SkImage* newImageShapshot();
+    SkImage* newImageSnapshot();
 
     /**
      *  Specify the maximum number of bytes to be allocated for the purpose
diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp
index 37995b1..8cce965 100644
--- a/src/image/SkSurface.cpp
+++ b/src/image/SkSurface.cpp
@@ -36,7 +36,7 @@
 
 void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y,
                             const SkPaint* paint) {
-    SkImage* image = this->newImageShapshot();
+    SkImage* image = this->newImageSnapshot();
     if (image) {
         image->draw(canvas, x, y, paint);
         image->unref();
@@ -53,7 +53,7 @@
 
 SkImage* SkSurface_Base::getCachedImage() {
     if (NULL == fCachedImage) {
-        fCachedImage = this->onNewImageShapshot();
+        fCachedImage = this->onNewImageSnapshot();
         this->installIntoCanvasForDirtyNotification();
     }
     return fCachedImage;
@@ -117,7 +117,7 @@
     return asSB(this)->getCachedCanvas();
 }
 
-SkImage* SkSurface::newImageShapshot() {
+SkImage* SkSurface::newImageSnapshot() {
     SkImage* image = asSB(this)->getCachedImage();
     SkSafeRef(image);   // the caller will call unref() to balance this
     return image;
diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h
index b9c4890..bda271b 100644
--- a/src/image/SkSurface_Base.h
+++ b/src/image/SkSurface_Base.h
@@ -31,7 +31,7 @@
      *  must faithfully represent the current contents, even if the surface
      *  is chaged after this calle (e.g. it is drawn to via its canvas).
      */
-    virtual SkImage* onNewImageShapshot() = 0;
+    virtual SkImage* onNewImageSnapshot() = 0;
 
     /**
      *  Default implementation:
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index 3c581c3..ec709ca 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -20,7 +20,7 @@
 
     virtual SkCanvas* onNewCanvas() SK_OVERRIDE;
     virtual SkSurface* onNewSurface(const SkImage::Info&) SK_OVERRIDE;
-    virtual SkImage* onNewImageShapshot() SK_OVERRIDE;
+    virtual SkImage* onNewImageSnapshot() SK_OVERRIDE;
     virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y,
                         const SkPaint*) SK_OVERRIDE;
     virtual void onCopyOnWrite(SkImage*, SkCanvas*) SK_OVERRIDE;
@@ -71,7 +71,7 @@
     return SkSurface::NewRenderTarget(fDevice->context(), info, sampleCount);
 }
 
-SkImage* SkSurface_Gpu::onNewImageShapshot() {
+SkImage* SkSurface_Gpu::onNewImageSnapshot() {
 
     GrRenderTarget* rt = (GrRenderTarget*) fDevice->accessRenderTarget();
 
diff --git a/src/image/SkSurface_Picture.cpp b/src/image/SkSurface_Picture.cpp
index bdc84b7..d7b84ec 100644
--- a/src/image/SkSurface_Picture.cpp
+++ b/src/image/SkSurface_Picture.cpp
@@ -21,7 +21,7 @@
 
     virtual SkCanvas* onNewCanvas() SK_OVERRIDE;
     virtual SkSurface* onNewSurface(const SkImage::Info&) SK_OVERRIDE;
-    virtual SkImage* onNewImageShapshot() SK_OVERRIDE;
+    virtual SkImage* onNewImageSnapshot() SK_OVERRIDE;
     virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y,
                         const SkPaint*) SK_OVERRIDE;
     virtual void onCopyOnWrite(SkImage*, SkCanvas*) SK_OVERRIDE;
@@ -55,7 +55,7 @@
     return SkSurface::NewPicture(info.fWidth, info.fHeight);
 }
 
-SkImage* SkSurface_Picture::onNewImageShapshot() {
+SkImage* SkSurface_Picture::onNewImageSnapshot() {
     if (fPicture) {
         return SkNewImageFromPicture(fPicture);
     } else {
diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp
index 6e972dd..b88d0e2 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -22,7 +22,7 @@
 
     virtual SkCanvas* onNewCanvas() SK_OVERRIDE;
     virtual SkSurface* onNewSurface(const SkImage::Info&) SK_OVERRIDE;
-    virtual SkImage* onNewImageShapshot() SK_OVERRIDE;
+    virtual SkImage* onNewImageSnapshot() SK_OVERRIDE;
     virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y,
                         const SkPaint*) SK_OVERRIDE;
     virtual void onCopyOnWrite(SkImage*, SkCanvas*) SK_OVERRIDE;
@@ -120,7 +120,7 @@
     canvas->drawBitmap(fBitmap, x, y, paint);
 }
 
-SkImage* SkSurface_Raster::onNewImageShapshot() {
+SkImage* SkSurface_Raster::onNewImageSnapshot() {
     return SkNewImageFromBitmap(fBitmap, fWeOwnThePixels);
 }
 
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index 21f717c..af70fd2 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -147,7 +147,7 @@
     SkCanvas* recordingCanvas();
     SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
     SkDevice* immediateDevice() const {return fImmediateDevice;}
-    SkImage* newImageShapshot();
+    SkImage* newImageSnapshot();
     bool isFreshFrame();
     bool hasPendingCommands();
     size_t storageAllocatedForRecording() const;
@@ -400,9 +400,9 @@
     return fRecordingCanvas;
 }
 
-SkImage* DeferredDevice::newImageShapshot() {
+SkImage* DeferredDevice::newImageSnapshot() {
     this->flush();
-    return fSurface ? fSurface->newImageShapshot() : NULL;
+    return fSurface ? fSurface->newImageSnapshot() : NULL;
 }
 
 uint32_t DeferredDevice::getDeviceCapabilities() {
@@ -620,10 +620,10 @@
     return notificationClient;
 }
 
-SkImage* SkDeferredCanvas::newImageShapshot() {
+SkImage* SkDeferredCanvas::newImageSnapshot() {
     DeferredDevice* deferredDevice = this->getDeferredDevice();
     SkASSERT(deferredDevice);
-    return deferredDevice ? deferredDevice->newImageShapshot() : NULL;
+    return deferredDevice ? deferredDevice->newImageSnapshot() : NULL;
 }
 
 bool SkDeferredCanvas::isFullFrame(const SkRect* rect,
diff --git a/tests/DeferredCanvasTest.cpp b/tests/DeferredCanvasTest.cpp
index 1e23457..35eaf8c 100644
--- a/tests/DeferredCanvasTest.cpp
+++ b/tests/DeferredCanvasTest.cpp
@@ -505,7 +505,7 @@
     SkAutoTUnref<SkSurface> aur(surface);
     SkDeferredCanvas canvas(surface);
 
-    SkImage* image1 = canvas.newImageShapshot();
+    SkImage* image1 = canvas.newImageSnapshot();
     SkAutoTUnref<SkImage> aur_i1(image1);
     PixelPtr pixels1 = getSurfacePixelPtr(surface, useGpu);
     // The following clear would normally trigger a copy on write, but
@@ -514,13 +514,13 @@
     // Obtaining a snapshot directly from the surface (as opposed to the
     // SkDeferredCanvas) will not trigger a flush of deferred draw operations
     // and will therefore return the same image as the previous snapshot.
-    SkImage* image2 = surface->newImageShapshot();
+    SkImage* image2 = surface->newImageSnapshot();
     SkAutoTUnref<SkImage> aur_i2(image2);
     // Images identical because of deferral
     REPORTER_ASSERT(reporter, image1->uniqueID() == image2->uniqueID());
     // Now we obtain a snpshot via the deferred canvas, which triggers a flush.
     // Because there is a pending clear, this will generate a different image.
-    SkImage* image3 = canvas.newImageShapshot();
+    SkImage* image3 = canvas.newImageSnapshot();
     SkAutoTUnref<SkImage> aur_i3(image3);
     REPORTER_ASSERT(reporter, image1->uniqueID() != image3->uniqueID());
     // Verify that backing store is now a different buffer because of copy on
diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp
index 95c76cb..5f2dca6 100644
--- a/tests/SurfaceTest.cpp
+++ b/tests/SurfaceTest.cpp
@@ -105,10 +105,10 @@
 
 #define EXPECT_COPY_ON_WRITE(command)                               \
     {                                                               \
-        SkImage* imageBefore = surface->newImageShapshot();         \
+        SkImage* imageBefore = surface->newImageSnapshot();         \
         SkAutoTUnref<SkImage> aur_before(imageBefore);              \
         canvas-> command ;                                          \
-        SkImage* imageAfter = surface->newImageShapshot();          \
+        SkImage* imageAfter = surface->newImageSnapshot();          \
         SkAutoTUnref<SkImage> aur_after(imageAfter);                \
         REPORTER_ASSERT(reporter, imageBefore != imageAfter);       \
     }
@@ -143,7 +143,7 @@
     SkAutoTUnref<SkSurface> aur_surface(surface);
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(1);
-    surface->newImageShapshot()->unref();  // Create and destroy SkImage
+    surface->newImageSnapshot()->unref();  // Create and destroy SkImage
     canvas->clear(2);
 }