Rename variables in SkCanvas::internalSaveLayer

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 1251 matching lines @@
     bool isOpaque = SkToBool(saveLayerFlags & kIsOpaque_SaveLayerFlag);
     SkPixelGeometry geo = fProps.pixelGeometry();
     if (paint) {
         // TODO: perhaps add a query to filters so we might preserve opaqueness...
         if (paint->getImageFilter() || paint->getColorFilter()) {
             isOpaque = false;
             geo = kUnknown_SkPixelGeometry;
         }
     }
 
-    SkBaseDevice* device = this->getTopDevice();
-    if (nullptr == device) {
+    SkBaseDevice* priorDevice = this->getTopDevice();
+    if (!priorDevice) {
         SkDebugf("Unable to find device for layer.");
         return;
     }
 
-    SkImageInfo info = make_layer_info(device->imageInfo(), ir.width(), ir.height(), isOpaque,
+    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);
-        SkBaseDevice* newDev = device->onCreateDevice(createInfo, paint);
-        if (nullptr == newDev) {
+        newDevice.reset(priorDevice->onCreateDevice(createInfo, paint));
+        if (!newDevice) {
             SkErrorInternals::SetError(kInternalError_SkError,
                                        "Unable to create device for layer.");
             return;
         }
-        device = newDev;
     }
-    device->setOrigin(ir.fLeft, ir.fTop);
+    newDevice->setOrigin(ir.fLeft, ir.fTop);
 
     if (rec.fBackdrop) {
-        draw_filter_into_device(fMCRec->fTopLayer->fDevice, rec.fBackdrop, device, fMCRec->fMatrix);
+        draw_filter_into_device(priorDevice, rec.fBackdrop, newDevice, fMCRec->fMatrix);
     }
 
-    DeviceCM* layer = new DeviceCM(device, paint, this, fConservativeRasterClip, stashedMatrix);
-    device->unref();
+    DeviceCM* layer = new DeviceCM(newDevice, paint, this, fConservativeRasterClip, stashedMatrix);
 
     layer->fNext = fMCRec->fTopLayer;
     fMCRec->fLayer = layer;
     fMCRec->fTopLayer = layer;    // this field is NOT an owner of layer
 }
 
 int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha) {
     if (0xFF == alpha) {
         return this->saveLayer(bounds, nullptr);
     } else {
@@ skipping 1806 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