Adding SkSurface support to SkDeferredCanvas

include/utils/SkDeferredCanvas.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDeferredCanvas_DEFINED
 #define SkDeferredCanvas_DEFINED
 
 #include "SkCanvas.h"
 #include "SkPixelRef.h"
 
 class DeferredDevice;
+class SkImage;
+class SkSurface;
 
 /** \class SkDeferredCanvas
     Subclass of SkCanvas that encapsulates an SkPicture or SkGPipe for deferred
     drawing. The main difference between this class and SkPictureRecord (the
     canvas provided by SkPicture) is that this is a full drop-in replacement
     for SkCanvas, while SkPictureRecord only supports draw operations.
     SkDeferredCanvas will transparently trigger the flushing of deferred
     draw operations when an attempt is made to access the pixel data.
 */
 class SK_API SkDeferredCanvas : public SkCanvas {
 public:
     class NotificationClient;
 
     SkDeferredCanvas();
 
     /** Construct a canvas with the specified device to draw into.
         Equivalent to calling default constructor, then setDevice.
         @param device Specifies a device for the canvas to draw into.
     */
     explicit SkDeferredCanvas(SkDevice* device);
 
+    /** Construct a canvas with the specified surface to draw into.
+        This constructor must be used for newImageSnapshot to work.
+        @param surface Specifies a surface for the canvas to draw into.
+    */
+    explicit SkDeferredCanvas(SkSurface* surface);
+
     virtual ~SkDeferredCanvas();
 
     /**
      *  Specify a device to be used by this canvas. Calling setDevice will
      *  release the previously set device, if any. Takes a reference on the
      *  device.
      *
      *  @param device The device that the canvas will raw into
      *  @return The device argument, for convenience.
      */
@@ skipping 40 matching lines @@
      */
     bool isFreshFrame() const;
 
     /**
      *  Returns true if the canvas has recorded draw commands that have
      *  not yet been played back.
      */
     bool hasPendingCommands() const;
 
     /**
+     *  Flushes pending draw commands, if any, and returns an image of the
+     *  current state of the surface pixels up to this point. Subsequent
+     *  changes to the surface (by drawing into its canvas) will not be
+     *  reflected in this image.  Will return NULL if the deferred canvas
+     *  was not constructed from an SkSurface.
+     */
+    SkImage* newImageShapshot();
+
+    /**
      *  Specify the maximum number of bytes to be allocated for the purpose
      *  of recording draw commands to this canvas.  The default limit, is
      *  64MB.
      *  @param maxStorage The maximum number of bytes to be allocated.
      */
     void setMaxRecordingStorage(size_t maxStorage);
 
     /**
      *  Returns the number of bytes currently allocated for the purpose of
      *  recording draw commands.
@@ skipping 128 matching lines @@
     void validate() const;
     void init();
     bool            fDeferredDrawing;
 
     friend class SkDeferredCanvasTester; // for unit testing
     typedef SkCanvas INHERITED;
 };
 
 
 #endif