Rename base device to root device in SkCanvas

Change-Id: Iaf19645f4845114b79d23ead34cf4a11dfd400d9
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/752539
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Michael Ludwig <michaelludwig@google.com>

Author: lhkbob

include/core/SkCanvas.h

@@ -2310,9 +2310,9 @@ class SK_API SkCanvas {
 
     // The bottom-most device in the stack, only changed by init(). Image properties and the final
     // canvas pixels are determined by this device.
-    SkDevice* baseDevice() const {
-        SkASSERT(fBaseDevice);
-        return fBaseDevice.get();
+    SkDevice* rootDevice() const {
+        SkASSERT(fRootDevice);
+        return fRootDevice.get();
     }
 
     // The top-most device in the stack, will change within saveLayer()'s. All drawing and clipping
@@ -2352,7 +2352,7 @@ class SK_API SkCanvas {
         std::unique_ptr<Layer> fLayer;
 
         // This points to the device of the top-most layer (which may be lower in the stack), or
-        // to the canvas's fBaseDevice. The MCRec does not own the device.
+        // to the canvas's fRootDevice. The MCRec does not own the device.
         SkDevice* fDevice;
 
         std::unique_ptr<BackImage> fBackImage;
@@ -2381,7 +2381,7 @@ class SK_API SkCanvas {
     MCRec*      fMCRec;
 
     // Installed via init()
-    sk_sp<SkDevice> fBaseDevice;
+    sk_sp<SkDevice> fRootDevice;
     const SkSurfaceProps fProps;
 
     int         fSaveCount;         // value returned by getSaveCount()

src/android/SkAndroidFrameworkUtils.cpp

@@ -19,7 +19,7 @@
 
 #if defined(SK_GANESH)
 bool SkAndroidFrameworkUtils::clipWithStencil(SkCanvas* canvas) {
-    return canvas->baseDevice()->android_utils_clipWithStencil();
+    return canvas->rootDevice()->android_utils_clipWithStencil();
 }
 #endif
 

src/core/SkCanvas.cpp

@@ -101,12 +101,12 @@ bool SkCanvas::wouldOverwriteEntireSurface(const SkRect* rect, const SkPaint* pa
 
     // if we're clipped at all, we can't overwrite the entire surface
     {
-        const SkDevice* base = this->baseDevice();
+        const SkDevice* root = this->rootDevice();
         const SkDevice* top = this->topDevice();
-        if (base != top) {
+        if (root != top) {
             return false;   // we're in a saveLayer, so conservatively don't assume we'll overwrite
         }
-        if (!base->isClipWideOpen()) {
+        if (!root->isClipWideOpen()) {
             return false;
         }
     }
@@ -267,11 +267,11 @@ void SkCanvas::resetForNextPicture(const SkIRect& bounds) {
 
     // We're peering through a lot of structs here.  Only at this scope do we
     // know that the device is a SkNoPixelsDevice.
-    SkASSERT(fBaseDevice->isNoPixelsDevice());
-    fBaseDevice = sk_make_sp<SkNoPixelsDevice>(bounds,
-                                               fBaseDevice->surfaceProps(),
-                                               fBaseDevice->imageInfo().refColorSpace());
-    fMCRec->reset(fBaseDevice.get());
+    SkASSERT(fRootDevice->isNoPixelsDevice());
+    fRootDevice = sk_make_sp<SkNoPixelsDevice>(bounds,
+                                               fRootDevice->surfaceProps(),
+                                               fRootDevice->imageInfo().refColorSpace());
+    fMCRec->reset(fRootDevice.get());
     fQuickRejectBounds = this->computeDeviceClipBounds();
 }
 
@@ -295,7 +295,7 @@ void SkCanvas::init(sk_sp<SkDevice> device) {
     SkASSERT(fProps.pixelGeometry() == device->surfaceProps().pixelGeometry());
 
     fSurfaceBase = nullptr;
-    fBaseDevice = std::move(device);
+    fRootDevice = std::move(device);
     fScratchGlyphRunBuilder = std::make_unique<sktext::GlyphRunBuilder>();
     fQuickRejectBounds = this->computeDeviceClipBounds();
 }
@@ -346,7 +346,7 @@ SkSurface* SkCanvas::getSurface() const {
 }
 
 SkISize SkCanvas::getBaseLayerSize() const {
-    return this->baseDevice()->imageInfo().dimensions();
+    return this->rootDevice()->imageInfo().dimensions();
 }
 
 SkDevice* SkCanvas::topDevice() const {
@@ -355,7 +355,7 @@ SkDevice* SkCanvas::topDevice() const {
 }
 
 bool SkCanvas::readPixels(const SkPixmap& pm, int x, int y) {
-    return pm.addr() && this->baseDevice()->readPixels(pm, x, y);
+    return pm.addr() && this->rootDevice()->readPixels(pm, x, y);
 }
 
 bool SkCanvas::readPixels(const SkImageInfo& dstInfo, void* dstP, size_t rowBytes, int x, int y) {
@@ -377,7 +377,7 @@ bool SkCanvas::writePixels(const SkBitmap& bitmap, int x, int y) {
 
 bool SkCanvas::writePixels(const SkImageInfo& srcInfo, const void* pixels, size_t rowBytes,
                            int x, int y) {
-    SkDevice* device = this->baseDevice();
+    SkDevice* device = this->rootDevice();
 
     // This check gives us an early out and prevents generation ID churn on the surface.
     // This is purely optional: it is a subset of the checks performed by SkWritePixelsRec.
@@ -1156,15 +1156,15 @@ sk_sp<SkSurface> SkCanvas::makeSurface(const SkImageInfo& info, const SkSurfaceP
 }
 
 sk_sp<SkSurface> SkCanvas::onNewSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
-    return this->baseDevice()->makeSurface(info, props);
+    return this->rootDevice()->makeSurface(info, props);
 }
 
 SkImageInfo SkCanvas::imageInfo() const {
     return this->onImageInfo();
 }
 
 SkImageInfo SkCanvas::onImageInfo() const {
-    return this->baseDevice()->imageInfo();
+    return this->rootDevice()->imageInfo();
 }
 
 bool SkCanvas::getProps(SkSurfaceProps* props) const {
@@ -1195,7 +1195,7 @@ bool SkCanvas::peekPixels(SkPixmap* pmap) {
 }
 
 bool SkCanvas::onPeekPixels(SkPixmap* pmap) {
-    return this->baseDevice()->peekPixels(pmap);
+    return this->rootDevice()->peekPixels(pmap);
 }
 
 void* SkCanvas::accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin) {
@@ -1354,7 +1354,7 @@ void SkCanvas::androidFramework_setDeviceClipRestriction(const SkIRect& rect) {
     // - Historically, the empty rect would reset the clip restriction but it only could do so
     //   partially since the device's clips wasn't adjusted. Resetting is now handled
     //   automatically via SkCanvas::restore(), so empty input rects are skipped.
-    SkASSERT(this->topDevice() == this->baseDevice()); // shouldn't be in a nested layer
+    SkASSERT(this->topDevice() == this->rootDevice()); // shouldn't be in a nested layer
     // and shouldn't already have a restriction
     SkASSERT(fClipRestrictionSaveCount < 0 && fClipRestrictionRect.isEmpty());
 
@@ -1379,7 +1379,7 @@ void SkCanvas::internal_private_resetClip() {
 
 void SkCanvas::onResetClip() {
     SkIRect deviceRestriction = this->topDevice()->imageInfo().bounds();
-    if (fClipRestrictionSaveCount >= 0 && this->topDevice() == this->baseDevice()) {
+    if (fClipRestrictionSaveCount >= 0 && this->topDevice() == this->rootDevice()) {
         // Respect the device clip restriction when resetting the clip if we're on the base device.
         // If we're not on the base device, then the "reset" applies to the top device's clip stack,
         // and the clip restriction will be respected automatically during a restore of the layer.

src/core/SkSpecialSurface.cpp

@@ -37,13 +37,13 @@ SkSpecialSurface::SkSpecialSurface(sk_sp<SkDevice> device, const SkIRect& subset
 sk_sp<SkSpecialImage> SkSpecialSurface::makeImageSnapshot() {
     fCanvas->restoreToCount(0);
 
-    // Because of the above 'restoreToCount(0)' we know we're getting the base device here.
-    SkDevice* baseDevice = SkCanvasPriv::TopDevice(fCanvas.get());
-    if (!baseDevice) {
+    // Because of the above 'restoreToCount(0)' we know we're getting the root device here.
+    SkDevice* rootDevice = SkCanvasPriv::TopDevice(fCanvas.get());
+    if (!rootDevice) {
         return nullptr;
     }
 
-    sk_sp<SkSpecialImage> image = baseDevice->snapSpecial(this->subset());
+    sk_sp<SkSpecialImage> image = rootDevice->snapSpecial(this->subset());
 
     fCanvas.reset();
     return image;

src/image/SkSurface_Raster.cpp

@@ -145,7 +145,7 @@ bool SkSurface_Raster::onCopyOnWrite(ContentChangeMode mode) {
         // what is being used by the image. Next we update the canvas to use
         // this as its backend, so we can't modify the image's pixels anymore.
         SkASSERT(this->getCachedCanvas());
-        SkBitmapDevice* bmDev = static_cast<SkBitmapDevice*>(this->getCachedCanvas()->baseDevice());
+        SkBitmapDevice* bmDev = static_cast<SkBitmapDevice*>(this->getCachedCanvas()->rootDevice());
         bmDev->replaceBitmapBackendForRasterSurface(fBitmap);
     }
     return true;

src/utils/SkNWayCanvas.cpp

@@ -53,7 +53,7 @@ void SkNWayCanvas::addCanvas(SkCanvas* canvas) {
         // We are using the nway canvas as a wrapper for the originally added canvas, and the device
         // on the nway may contradict calls for the device on this canvas. So, to add a second
         // canvas, the devices on the first canvas, and the nway base device must be different.
-        SkASSERT(fList[0]->baseDevice() != this->baseDevice());
+        SkASSERT(fList[0]->rootDevice() != this->rootDevice());
     }
     if (canvas) {
         *fList.append() = canvas;

src/utils/SkTestCanvas.cpp

@@ -28,7 +28,7 @@
 class SkPaint;
 
 SkTestCanvas<SkSlugTestKey>::SkTestCanvas(SkCanvas* canvas)
-        : SkCanvas(sk_ref_sp(canvas->baseDevice())) {}
+        : SkCanvas(sk_ref_sp(canvas->rootDevice())) {}
 
 void SkTestCanvas<SkSlugTestKey>::onDrawGlyphRunList(
         const sktext::GlyphRunList& glyphRunList, const SkPaint& paint) {
@@ -48,7 +48,7 @@ void SkTestCanvas<SkSlugTestKey>::onDrawGlyphRunList(
 }
 
 SkTestCanvas<SkSerializeSlugTestKey>::SkTestCanvas(SkCanvas* canvas)
-        : SkCanvas(sk_ref_sp(canvas->baseDevice())) {}
+        : SkCanvas(sk_ref_sp(canvas->rootDevice())) {}
 
 void SkTestCanvas<SkSerializeSlugTestKey>::onDrawGlyphRunList(
         const sktext::GlyphRunList& glyphRunList, const SkPaint& paint) {
@@ -124,7 +124,7 @@ class ClientHandleManager : public SkStrikeClient::DiscardableHandleManager {
 };
 
 SkTestCanvas<SkRemoteSlugTestKey>::SkTestCanvas(SkCanvas* canvas)
-        : SkCanvas(sk_ref_sp(canvas->baseDevice()))
+        : SkCanvas(sk_ref_sp(canvas->rootDevice()))
         , fServerHandleManager(new ServerHandleManager{})
         , fClientHandleManager(new ClientHandleManager{})
         , fStrikeServer(fServerHandleManager.get())