Changing SkDeferredCanvas to use factories for creation

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;
 
+#if !defined(SK_DEFERRED_CANVAS_USES_FACTORIES)
+// This is temporary, for rolling the API change into Chromium/Blink
+#define SK_DEFERRED_CANVAS_USES_FACTORIES 0
+#endif
+
 /** \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;
 
+    /** Construct a canvas with the specified surface to draw into.
+        This factory must be used for newImageSnapshot to work.
+        @param surface Specifies a surface for the canvas to draw into.
+     */
+    static SkDeferredCanvas* Create(SkSurface* surface);
+
+#ifdef SK_DEVELOPER
+    static SkDeferredCanvas* Create(SkDevice* device); // Used for testing
+#endif
+
+#if !SK_DEFERRED_CANVAS_USES_FACTORIES
+    /** DEPRECATED
+     */
     SkDeferredCanvas();
 
-    /** Construct a canvas with the specified device to draw into.
+    /** DEPRACATED, use create instead
+        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.
+    /** DEPRECATED, use create instead
+        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);
+#endif
 
     virtual ~SkDeferredCanvas();
 
-    /**
+    /** DEPRECATED
      *  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.
      */
     virtual SkDevice* setDevice(SkDevice* device);
 
     /**
@@ skipping 190 matching lines @@
          *  or completely overwritten by the command currently being recorded.
          */
         virtual void skippedPendingDrawCommands() {}
     };
 
 protected:
     virtual SkCanvas* canvasForDrawIter();
     DeferredDevice* getDeferredDevice() const;
 
 private:
+    SkDeferredCanvas(DeferredDevice*);
+
     void recordedDrawCommand();
     SkCanvas* drawingCanvas() const;
     SkCanvas* immediateCanvas() const;
     bool isFullFrame(const SkRect*, const SkPaint*) const;
     void validate() const;
     void init();
     bool            fDeferredDrawing;
 
     friend class SkDeferredCanvasTester; // for unit testing
     typedef SkCanvas INHERITED;
 };
 
 
 #endif