Infrastructure changes to support pull saveLayers forward task

src/gpu/GrPictureUtils.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPictureUtils.h"
 #include "SkDevice.h"
+#include "SkDraw.h"
+#include "SkPaintPriv.h"
+
+SkPicture::AccelData::Key GPUAccelData::ComputeAccelDataKey() {
+    static const SkPicture::AccelData::Key gGPUID = SkPicture::AccelData::GenerateDomain();
+
+    return gGPUID;
+}
 
 // The GrGather device performs GPU-backend-specific preprocessing on
 // a picture. The results are stored in a GPUAccelData.
 //
 // Currently the only interesting work is done in drawDevice (i.e., when a
 // saveLayer is collapsed back into its parent) and, maybe, in onCreateDevice.
 // All the current work could be done much more efficiently by just traversing the
 // raw op codes in the SkPicture (although we would still need to replay all the
 // clip calls).
 class GrGatherDevice : public SkBaseDevice {
 public:
     SK_DECLARE_INST_COUNT(GrGatherDevice)
 
-    GrGatherDevice(int width, int height, SkPicture* picture, GPUAccelData* accelData) {
+    GrGatherDevice(int width, int height, SkPicture* picture, GPUAccelData* accelData,
+                   int saveLayerDepth) {
         fPicture = picture;
+        fSaveLayerDepth = saveLayerDepth;
+        fInfo.fValid = true;
         fInfo.fSize.set(width, height);
+        fInfo.fPaint = NULL;
         fInfo.fSaveLayerOpID = fPicture->EXPERIMENTAL_curOpID();
         fInfo.fRestoreOpID = 0;
         fInfo.fHasNestedLayers = false;
+        fInfo.fIsNested = (2 == fSaveLayerDepth);
 
         fEmptyBitmap.setConfig(SkImageInfo::Make(fInfo.fSize.fWidth,
                                                  fInfo.fSize.fHeight,
                                                  kUnknown_SkColorType,
                                                  kIgnore_SkAlphaType));
         fAccelData = accelData;
         fAlreadyDrawn = false;
     }
 
     virtual ~GrGatherDevice() { }
@@ skipping 64 matching lines @@
                                 const SkPath& path, const SkMatrix* matrix,
                                 const SkPaint& paint) SK_OVERRIDE {
     }
     virtual void drawVertices(const SkDraw& draw, SkCanvas::VertexMode, int vertexCount,
                               const SkPoint verts[], const SkPoint texs[],
                               const SkColor colors[], SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) SK_OVERRIDE {
     }
     virtual void drawDevice(const SkDraw& draw, SkBaseDevice* deviceIn, int x, int y,
-                            const SkPaint&) SK_OVERRIDE {
+                            const SkPaint& paint) SK_OVERRIDE {
+        // deviceIn is the one that is being "restored" back to its parent
         GrGatherDevice* device = static_cast<GrGatherDevice*>(deviceIn);
 
         if (device->fAlreadyDrawn) {
             return;
         }
 
         device->fInfo.fRestoreOpID = fPicture->EXPERIMENTAL_curOpID();
+        device->fInfo.fCTM = *draw.fMatrix;
+        device->fInfo.fCTM.postTranslate(SkIntToScalar(-device->getOrigin().fX),
+                                         SkIntToScalar(-device->getOrigin().fY));
+
+        // We need the x & y values that will yield 'getOrigin' when transformed
+        // by 'draw.fMatrix'.
+        device->fInfo.fOffset.iset(device->getOrigin());
+
+        SkMatrix invMatrix;
+        if (draw.fMatrix->invert(&invMatrix)) {
+            invMatrix.mapPoints(&device->fInfo.fOffset, 1);
+        } else {
+            device->fInfo.fValid = false;
+        }
+
+        if (NeedsDeepCopy(paint)) {
+            // This NULL acts as a signal that the paint was uncopyable (for now)
+            device->fInfo.fPaint = NULL;
+            device->fInfo.fValid = false;
+        } else {
+            device->fInfo.fPaint = SkNEW_ARGS(SkPaint, (paint));
+        }
+
         fAccelData->addSaveLayerInfo(device->fInfo);
         device->fAlreadyDrawn = true;
     }
     // TODO: allow this call to return failure, or move to SkBitmapDevice only.
     virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE {
         return fEmptyBitmap;
     }
 #ifdef SK_SUPPORT_LEGACY_READPIXELSCONFIG
     virtual bool onReadPixels(const SkBitmap& bitmap,
                               int x, int y,
@@ skipping 20 matching lines @@
     // All information gathered during the gather process is stored here
     GPUAccelData* fAccelData;
 
     // true if this device has already been drawn back to its parent(s) at least
     // once.
     bool   fAlreadyDrawn;
 
     // The information regarding the saveLayer call this device represents.
     GPUAccelData::SaveLayerInfo fInfo;
 
+    // The depth of this device in the saveLayer stack
+    int fSaveLayerDepth;
+
     virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE {
         NotSupported();
     }
 
     virtual SkBaseDevice* onCreateDevice(const SkImageInfo& info, Usage usage) SK_OVERRIDE {
         // we expect to only get called via savelayer, in which case it is fine.
         SkASSERT(kSaveLayer_Usage == usage);
 
         fInfo.fHasNestedLayers = true;
-        return SkNEW_ARGS(GrGatherDevice, (info.width(), info.height(), fPicture, fAccelData));
+        return SkNEW_ARGS(GrGatherDevice, (info.width(), info.height(), fPicture, 
+                                           fAccelData, fSaveLayerDepth+1));
     }
 
     virtual void flush() SK_OVERRIDE {}
 
     static void NotSupported() {
         SkDEBUGFAIL("this method should never be called");
     }
 
     static void NothingToDo() {}
 
@@ skipping 51 matching lines @@
     typedef SkCanvas INHERITED;
 };
 
 // GatherGPUInfo is only intended to be called within the context of SkGpuDevice's
 // EXPERIMENTAL_optimize method.
 void GatherGPUInfo(SkPicture* pict, GPUAccelData* accelData) {
     if (0 == pict->width() || 0 == pict->height()) {
         return ;
     }
 
-    GrGatherDevice device(pict->width(), pict->height(), pict, accelData);
+    GrGatherDevice device(pict->width(), pict->height(), pict, accelData, 0);
     GrGatherCanvas canvas(&device, pict);
 
     canvas.gather();
 }