support direct writing to top layer

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkClipStack.h"
 #include "SkPaint.h"
 #include "SkRefCnt.h"
 #include "SkPath.h"
 #include "SkRegion.h"
 #include "SkXfermode.h"
 
 // if not defined, we always assume ClipToLayer for saveLayer()
 //#define SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
 
 
 //#define SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG
 //#define SK_SUPPORT_LEGACY_GETCLIPTYPE
 //#define SK_SUPPORT_LEGACY_GETTOTALCLIP
+//#define SK_SUPPORT_LEGACY_GETTOPDEVICE
 
 class SkBounder;
 class SkBaseDevice;
 class SkDraw;
 class SkDrawFilter;
 class SkMetaData;
 class SkPicture;
 class SkRRect;
 class SkSurface;
 class SkSurface_Base;
 class GrContext;
+class GrRenderTarget;
 
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
     This includes a reference to the device itself, and a stack of matrix/clip
     values. For any given draw call (e.g. drawRect), the geometry of the object
     being drawn is transformed by the concatenation of all the matrices in the
     stack. The transformed geometry is clipped by the intersection of all of
     the clips in the stack.
 
@@ skipping 103 matching lines @@
      *  installed. Note that this can change on other calls like save/restore,
      *  so do not access this device after subsequent canvas calls.
      *  The reference count of the device is not changed.
      *
      * @param updateMatrixClip If this is true, then before the device is
      *        returned, we ensure that its has been notified about the current
      *        matrix and clip. Note: this happens automatically when the device
      *        is drawn to, but is optional here, as there is a small perf hit
      *        sometimes.
      */
+#ifndef SK_SUPPORT_LEGACY_GETTOPDEVICE
+private:
+#endif
     SkBaseDevice* getTopDevice(bool updateMatrixClip = false) const;
+public:
 
     /**
      *  Create a new surface matching the specified info, one that attempts to
      *  be maximally compatible when used with this canvas.
      */
     SkSurface* newSurface(const SkImageInfo&);
 
     /**
      * Return the GPU context of the device that is associated with the canvas.
      * For a canvas with non-GPU device, NULL is returned.
      */
     GrContext* getGrContext();
 
     ///////////////////////////////////////////////////////////////////////////
 
     /**
-     *  If the canvas has pixels (and is not recording to a picture or other
-     *  non-raster target) and has direct access to its pixels (i.e. they are in
+     *  If the canvas has writable pixels in its top layer (and is not recording to a picture
+     *  or other non-raster target) and has direct access to its pixels (i.e. they are in
      *  local RAM) return the const-address of those pixels, and if not null,

[bsalomon, 2014/03/12 14:43:11]

This comment should be updated to indicate that the pointer is writable.

[reed1, 2014/03/12 15:31:59]

Done.

      *  return the ImageInfo and rowBytes. The returned address is only valid
      *  while the canvas object is in scope and unchanged. Any API calls made on
+     *  canvas (or its parent surface if any) will invalidate the
+     *  returned address (and associated information).
+     *
+     *  On failure, returns NULL and the info and rowBytes parameters are
+     *  ignored.
+     */
+    void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes);
+
+    /**
+     *  If the canvas has readable pixels in its base layer (and is not recording to a picture
+     *  or other non-raster target) and has direct access to its pixels (i.e. they are in
+     *  local RAM) return the const-address of those pixels, and if not null,
+     *  return the ImageInfo and rowBytes. The returned address is only valid
+     *  while the canvas object is in scope and unchanged. Any API calls made on
      *  canvas (or its parent surface if any) will invalidate the
      *  returned address (and associated information).
      *
      *  On failure, returns NULL and the info and rowBytes parameters are
      *  ignored.
      */
     const void* peekPixels(SkImageInfo* info, size_t* rowBytes);
 
     /**
      * This enum can be used with read/writePixels to perform a pixel ops to or
@@ skipping 969 matching lines @@
         intptr_t          fStorage[32];
         class SkDrawIter* fImpl;    // this points at fStorage
         SkPaint           fDefaultPaint;
         bool              fDone;
     };
 
     // don't call
     const SkRegion& internal_private_getTotalClip() const;
     // don't call
     void internal_private_getTotalClipAsPath(SkPath*) const;
+    // don't call
+    GrRenderTarget* internal_private_accessTopLayerRenderTarget();
 
 protected:
     // default impl defers to getDevice()->newSurface(info)
     virtual SkSurface* onNewSurface(const SkImageInfo&);
 
     // default impl defers to its device
     virtual const void* onPeekPixels(SkImageInfo*, size_t* rowBytes);
+    virtual void* onAccessTopLayerPixels(SkImageInfo*, size_t* rowBytes);
 
     // Subclass save/restore notifiers. These are called *before* updating the canvas state.
     // Overriders should call the corresponding INHERITED method up the inheritance chain.
     // For onSaveLayer(), returning false suppresses full layer allocation (and forces
     // the base impl to only perform a state save + bounds clip).
     virtual void onSave(SaveFlags);
     virtual bool onSaveLayer(const SkRect*, const SkPaint*, SaveFlags);
     virtual void onRestore();
 
     virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&);
@@ skipping 54 matching lines @@
     SkSurface_Base* getSurfaceBase() const { return fSurfaceBase; }
     void setSurfaceBase(SkSurface_Base* sb) {
         fSurfaceBase = sb;
     }
     friend class SkSurface_Base;
     friend class SkSurface_Gpu;
 
     bool fDeviceCMDirty;            // cleared by updateDeviceCMCache()
     void updateDeviceCMCache();
 
-    friend class SkDrawIter;    // needs setupDrawForLayerDevice()
+    friend class SkDrawIter;        // needs setupDrawForLayerDevice()
     friend class AutoDrawLooper;
-    friend class SkLua;         // needs top layer size and offset
+    friend class SkLua;             // needs top layer size and offset
+    friend class SkDeferredDevice;  // needs getTopDevice()
 
     SkBaseDevice* createLayerDevice(const SkImageInfo&);
 
     SkBaseDevice* init(SkBaseDevice*);
 
     /**
      *  DEPRECATED
      *
      *  Specify a device for this canvas to draw into. If it is not null, its
      *  reference count is incremented. If the canvas was already holding a
@@ skipping 164 matching lines @@
     bool asROBitmap(SkBitmap*) const;
 
 private:
     SkBitmap    fBitmap;    // used if peekPixels() fails
     const void* fAddr;      // NULL on failure
     SkImageInfo fInfo;
     size_t      fRowBytes;
 };
 
 #endif