WIP RasterCanvasLayerAllocator experiment 2

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 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.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 678 matching lines @@
         fDeviceClipBounds = qr_clip_bounds(device->getGlobalBounds());
     }
 
     return device;
 }
 
 SkCanvas::SkCanvas()
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(SkSurfaceProps::kLegacyFontHost_InitType)
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)

[reed1, 2016/09/16 13:15:00]

Are any of these (nullptr) initializers needed, given that fLayerAllocator is a
smart container?

[tomhudson, 2016/09/28 21:23:57]

Done.

 {
     inc_canvas();
 
     this->init(nullptr, kDefault_InitFlags);
 }
 
 static SkBitmap make_nopixels(int width, int height) {
     SkBitmap bitmap;
     bitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
     return bitmap;
 }
 
 class SkNoPixelsBitmapDevice : public SkBitmapDevice {
 public:
     SkNoPixelsBitmapDevice(const SkIRect& bounds, const SkSurfaceProps& surfaceProps)
         : INHERITED(make_nopixels(bounds.width(), bounds.height()), surfaceProps)
     {
         this->setOrigin(bounds.x(), bounds.y());
     }
 
 private:
 
     typedef SkBitmapDevice INHERITED;
 };
 
 SkCanvas::SkCanvas(int width, int height, const SkSurfaceProps* props)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(SkSurfacePropsCopyOrDefault(props))
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)
 {
     inc_canvas();
 
     this->init(new SkNoPixelsBitmapDevice(SkIRect::MakeWH(width, height), fProps),
                kDefault_InitFlags)->unref();
 }
 
 SkCanvas::SkCanvas(const SkIRect& bounds, InitFlags flags)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(SkSurfaceProps::kLegacyFontHost_InitType)
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)
 {
     inc_canvas();
 
     this->init(new SkNoPixelsBitmapDevice(bounds, fProps), flags)->unref();
 }
 
 SkCanvas::SkCanvas(SkBaseDevice* device)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(device->surfaceProps())
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)
 {
     inc_canvas();
 
     this->init(device, kDefault_InitFlags);
 }
 
 SkCanvas::SkCanvas(SkBaseDevice* device, InitFlags flags)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(device->surfaceProps())
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)
 {
     inc_canvas();
 
     this->init(device, flags);
 }
 
 SkCanvas::SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(props)
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)
 {
     inc_canvas();
 
     SkAutoTUnref<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
     this->init(device, kDefault_InitFlags);
 }
 
 SkCanvas::SkCanvas(const SkBitmap& bitmap)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
     , fProps(SkSurfaceProps::kLegacyFontHost_InitType)
     , fConservativeRasterClip(false)
+    , fLayerAllocator(nullptr)
 {
     inc_canvas();
 
+    SkAutoTUnref<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
+    this->init(device, kDefault_InitFlags);
+}
+
+SkCanvas::SkCanvas(const SkBitmap& bitmap,
+                   SkRasterCanvasLayerAllocator* allocator)
+    : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
+    , fProps(SkSurfaceProps::kLegacyFontHost_InitType)
+    , fConservativeRasterClip(false)
+    , fLayerAllocator(allocator)
+{
+    inc_canvas();
+

[tomhudson, 2016/09/16 12:48:28]

Should probably put an SkASSERT() here to guarantee that the bitmap backing, if
any, comes from the allocator, but that's complicated.

     SkAutoTUnref<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
     this->init(device, kDefault_InitFlags);
 }
 
 SkCanvas::~SkCanvas() {
     // free up the contents of our deque
     this->restoreToCount(1);    // restore everything but the last
 
     this->internalRestore();    // restore the last, since we're going away
 
@@ skipping 466 matching lines @@
     SkImageInfo info = make_layer_info(priorDevice->imageInfo(), ir.width(), ir.height(), isOpaque,
                                        paint);
 
     SkAutoTUnref<SkBaseDevice> newDevice;
     {
         const bool preserveLCDText = kOpaque_SkAlphaType == info.alphaType() ||
                                      (saveLayerFlags & kPreserveLCDText_SaveLayerFlag);
         const SkBaseDevice::TileUsage usage = SkBaseDevice::kNever_TileUsage;
         const SkBaseDevice::CreateInfo createInfo = SkBaseDevice::CreateInfo(info, usage, geo,
                                                                              preserveLCDText);
-        newDevice.reset(priorDevice->onCreateDevice(createInfo, paint));
+        newDevice.reset(priorDevice->onCreateDevice(createInfo, paint, fLayerAllocator.get()));
         if (!newDevice) {
             SkErrorInternals::SetError(kInternalError_SkError,
                                        "Unable to create device for layer.");
             return;
         }
     }
     newDevice->setOrigin(ir.fLeft, ir.fTop);
 
     DeviceCM* layer = new DeviceCM(newDevice, paint, this, fConservativeRasterClip, stashedMatrix);
 
@@ skipping 2224 matching lines @@
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }
 
 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     return this->makeSurface(info, props).release();
 }
 #endif