rename FoceCopyMode to SkCopyPixelMode

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2220603002

Review-Url: https://codereview.chromium.org/2220603002

19 files changed, 69 insertions, 70 deletions

diff --git a/gm/lightingshader.cpp b/gm/lightingshader.cpp
index 2cf4a953d8..54318ee445 100644
--- a/gm/lightingshader.cpp
+++ b/gm/lightingshader.cpp
@@ -6,8 +6,6 @@
  */
 
 #include "gm.h"
-
-#include "SkBitmapProcShader.h"
 #include "SkLightingShader.h"
 #include "SkNormalSource.h"
 #include "SkPoint3.h"
@@ -100,10 +98,10 @@ protected:
         const SkMatrix& ctm = canvas->getTotalMatrix();
 
         SkPaint paint;
-        sk_sp<SkShader> diffuseShader = SkMakeBitmapShader(fDiffuse,
-                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix, nullptr);
-        sk_sp<SkShader> normalMap = SkMakeBitmapShader(fNormalMaps[mapType],
-                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix, nullptr);
+        sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(fDiffuse,
+                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
+        sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fNormalMaps[mapType],
+                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
                                                                                ctm);
         paint.setShader(SkLightingShader::Make(std::move(diffuseShader), std::move(normalSource),
diff --git a/gm/lightingshader2.cpp b/gm/lightingshader2.cpp
index 9283449e2c..5e0d19b661 100644
--- a/gm/lightingshader2.cpp
+++ b/gm/lightingshader2.cpp
@@ -6,8 +6,6 @@
  */
 
 #include "gm.h"
-
-#include "SkBitmapProcShader.h"
 #include "SkLightingShader.h"
 #include "SkNormalSource.h"
 #include "SkPoint3.h"
@@ -60,20 +58,21 @@ protected:
                 sk_tool_utils::color_to_565(0x0),
                 sk_tool_utils::color_to_565(0xFF804020),
                 8);
-        fOpaqueDiffuse = SkMakeBitmapShader(opaqueDiffuseMap, SkShader::kClamp_TileMode,
-                                            SkShader::kClamp_TileMode, &matrix, nullptr);
+        fOpaqueDiffuse = SkShader::MakeBitmapShader(opaqueDiffuseMap, SkShader::kClamp_TileMode,
+                                                    SkShader::kClamp_TileMode, &matrix);
 
         SkBitmap translucentDiffuseMap = sk_tool_utils::create_checkerboard_bitmap(
                 kTexSize, kTexSize,
                 SkColorSetARGB(0x55, 0x00, 0x00, 0x00),
                 SkColorSetARGB(0x55, 0x80, 0x40, 0x20),
                 8);
-        fTranslucentDiffuse = SkMakeBitmapShader(translucentDiffuseMap, SkShader::kClamp_TileMode,
-                                                 SkShader::kClamp_TileMode, &matrix, nullptr);
+        fTranslucentDiffuse = SkShader::MakeBitmapShader(translucentDiffuseMap,
+                                                         SkShader::kClamp_TileMode,
+                                                         SkShader::kClamp_TileMode, &matrix);
 
         SkBitmap normalMap = make_frustum_normalmap(kTexSize);
-        fNormalMapShader = SkMakeBitmapShader(normalMap, SkShader::kClamp_TileMode,
-                                              SkShader::kClamp_TileMode, &matrix, nullptr);
+        fNormalMapShader = SkShader::MakeBitmapShader(normalMap, SkShader::kClamp_TileMode,
+                                                      SkShader::kClamp_TileMode, &matrix);
 
     }
 
diff --git a/gm/lightingshaderbevel.cpp b/gm/lightingshaderbevel.cpp
index d119a27cbd..dfc46e4471 100644
--- a/gm/lightingshaderbevel.cpp
+++ b/gm/lightingshaderbevel.cpp
@@ -6,8 +6,6 @@
  */
 
 #include "gm.h"
-
-#include "SkBitmapProcShader.h"
 #include "SkLightingShader.h"
 #include "SkNormalSource.h"
 #include "SkPath.h"
@@ -54,8 +52,8 @@ protected:
                 sk_tool_utils::color_to_565(0x0),
                 sk_tool_utils::color_to_565(0xFF804020),
                 8);
-        fDiffuse = SkMakeBitmapShader(diffuseMap, SkShader::kClamp_TileMode,
-                                      SkShader::kClamp_TileMode, &matrix, nullptr);
+        fDiffuse = SkShader::MakeBitmapShader(diffuseMap, SkShader::kClamp_TileMode,
+                                              SkShader::kClamp_TileMode, &matrix);
 
         fConvexPath.moveTo(fRect.width() / 2.0f, 0.0f);
         fConvexPath.lineTo(0.0f, fRect.height());
diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp
index dbab0928cb..1c86c99362 100755
--- a/samplecode/SampleLighting.cpp
+++ b/samplecode/SampleLighting.cpp
@@ -4,11 +4,10 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "DecodeFile.h"
 #include "SampleCode.h"
 #include "Resources.h"
-
-#include "SkBitmapProcShader.h"
 #include "SkCanvas.h"
 #include "SkLightingShader.h"
 #include "SkNormalSource.h"
@@ -66,8 +65,8 @@ protected:
 
         sk_sp<SkLights> lights(create_lights(fLightAngle, fColorFactor));
         SkPaint paint;
-        sk_sp<SkShader> normalMap = SkMakeBitmapShader(fNormalBitmap,
-            SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr, nullptr);
+        sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fNormalBitmap,
+            SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
                 std::move(normalMap), SkMatrix::I());
         sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(fDiffuseBitmap,
diff --git a/samplecode/SampleLitAtlas.cpp b/samplecode/SampleLitAtlas.cpp
index cb42d392e4..5f62e2abfb 100644
--- a/samplecode/SampleLitAtlas.cpp
+++ b/samplecode/SampleLitAtlas.cpp
@@ -130,8 +130,8 @@ protected:
             SkMatrix m;
             m.setRSXform(xforms[i]);
 
-            sk_sp<SkShader> normalMap = SkMakeBitmapShader(fAtlas, SkShader::kClamp_TileMode,
-                    SkShader::kClamp_TileMode, &normalMat, nullptr);
+            sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fAtlas, SkShader::kClamp_TileMode,
+                    SkShader::kClamp_TileMode, &normalMat);
             sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
                     std::move(normalMap), m);
             sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(fAtlas,
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index 79b62abe2c..41416e733b 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -329,7 +329,7 @@ void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
     SkTBlitterAllocator allocator;
     // construct a shader, so we can call drawRect with the dst
     auto s = SkMakeBitmapShader(*bitmapPtr, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
-                                &matrix, &allocator);
+                                &matrix, kNever_SkCopyPixelsMode, &allocator);
     if (!s) {
         return;
     }
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index c0e6a407ce..edb9864270 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -7,6 +7,7 @@
 #ifndef SkBitmapProcShader_DEFINED
 #define SkBitmapProcShader_DEFINED
 
+#include "SkImagePriv.h"
 #include "SkShader.h"
 #include "SkSmallAllocator.h"
 
@@ -36,6 +37,7 @@ typedef SkSmallAllocator<3, kSkBlitterContextSize> SkTBlitterAllocator;
 // If alloc is non-nullptr, it will be used to allocate the returned SkShader, and MUST outlive
 // the SkShader.
 sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode,
-                                   const SkMatrix* localMatrix, SkTBlitterAllocator* alloc);
+                                   const SkMatrix* localMatrix, SkCopyPixelsMode,
+                                   SkTBlitterAllocator* alloc);
 
 #endif
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index ce4c4081f2..487b46b05e 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -83,7 +83,9 @@ public:
                               const SkMatrix* localMatrix = nullptr)
             : fPaint(paint) /* makes a copy of the paint */ {
         fPaint.setShader(SkMakeBitmapShader(src, SkShader::kClamp_TileMode,
-                                            SkShader::kClamp_TileMode, localMatrix, &fAllocator));
+                                            SkShader::kClamp_TileMode, localMatrix,
+                                            kNever_SkCopyPixelsMode,
+                                            &fAllocator));
         // we deliberately left the shader with an owner-count of 2
         fPaint.getShader()->ref();
         SkASSERT(2 == fPaint.getShader()->getRefCnt());
diff --git a/src/image/SkImagePriv.h b/src/core/SkImagePriv.h
index 9cdcbb6f93..ed40996acd 100644
--- a/src/image/SkImagePriv.h
+++ b/src/core/SkImagePriv.h
@@ -16,12 +16,18 @@ extern sk_sp<SkImage> SkMakeImageFromPixelRef(const SkImageInfo&, SkPixelRef*,
                                               const SkIPoint& pixelRefOrigin,
                                               size_t rowBytes);
 
+enum SkCopyPixelsMode {
+    kIfMutable_SkCopyPixelsMode,  //!< only copy src pixels if they are marked mutable
+    kAlways_SkCopyPixelsMode,     //!< always copy src pixels (even if they are marked immutable)
+    kNever_SkCopyPixelsMode,      //!< never copy src pixels (even if they are marked mutable)
+};
+
 /**
  *  Examines the bitmap to decide if it can share the existing pixelRef, or
  *  if it needs to make a deep-copy of the pixels.
  *
  *  The bitmap's pixelref will be shared if either the bitmap is marked as
- *  immutable, or forceSharePixelRef is true.  Shared pixel refs are also
+ *  immutable, or CopyPixelsMode allows it. Shared pixel refs are also
  *  locked when kLocked_SharedPixelRefMode is specified.
  *
  *  Passing kLocked_SharedPixelRefMode allows the image's peekPixels() method
@@ -34,13 +40,7 @@ extern sk_sp<SkImage> SkMakeImageFromPixelRef(const SkImageInfo&, SkPixelRef*,
  *  SkImageInfo, or the bitmap's pixels cannot be accessed, this will return
  *  nullptr.
  */
-enum ForceCopyMode {
-    kNo_ForceCopyMode,
-    kYes_ForceCopyMode,     // must copy the pixels even if the bitmap is immutable
-    kNever_ForceCopyMode,   // don't ever copy, even if the bitmap is mutable
-};
-extern sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap&,
-                                                  ForceCopyMode = kNo_ForceCopyMode);
+extern sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap&, SkCopyPixelsMode);
 
 // Given an image created from SkNewImageFromBitmap, return its pixelref. This
 // may be called to see if the surface and the image share the same pixelref,
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 5fa5ec239c..56011c5784 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -240,7 +240,7 @@ sk_sp<SkShader> SkShader::MakeColorShader(SkColor color) { return sk_make_sp<SkC
 
 sk_sp<SkShader> SkShader::MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
                                            const SkMatrix* localMatrix) {
-    return SkMakeBitmapShader(src, tmx, tmy, localMatrix, nullptr);
+    return SkMakeBitmapShader(src, tmx, tmy, localMatrix, kIfMutable_SkCopyPixelsMode, nullptr);
 }
 
 sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<SkPicture> src, TileMode tmx, TileMode tmy,
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 15c5ea6bd8..2d434aee19 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -309,8 +309,7 @@ sk_sp<SkImage> SkImage::MakeFromBitmap(const SkBitmap& bm) {
     }
 #endif
 
-    // This will check for immutable (share or copy)
-    return SkMakeImageFromRasterBitmap(bm);
+    return SkMakeImageFromRasterBitmap(bm, kIfMutable_SkCopyPixelsMode);
 }
 
 bool SkImage::asLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) const {
diff --git a/src/image/SkImageShader.cpp b/src/image/SkImageShader.cpp
index a486f71dfd..5fbb0a9b9f 100644
--- a/src/image/SkImageShader.cpp
+++ b/src/image/SkImageShader.cpp
@@ -234,9 +234,14 @@ sk_sp<GrFragmentProcessor> SkImageShader::asFragmentProcessor(const AsFPArgs& ar
 
 sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
                                    SkShader::TileMode tmy, const SkMatrix* localMatrix,
-                                   SkTBlitterAllocator* allocator) {
-    ForceCopyMode mode = allocator ? kNever_ForceCopyMode : kNo_ForceCopyMode;
-    return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, mode).get(),
+                                   SkCopyPixelsMode cpm, SkTBlitterAllocator* allocator) {
+    // Until we learn otherwise, it seems that any caller that is passing an allocator must be
+    // assuming that the returned shader will have a stack-frame lifetime, so we assert that
+    // they are also asking for kNever_SkCopyPixelsMode. If that proves otherwise, we can remove
+    // or modify this assert.
+    SkASSERT(!allocator || (kNever_SkCopyPixelsMode == cpm));
+
+    return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm).get(),
                                tmx, tmy, localMatrix, allocator);
 }
 
diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp
index 192a4e03ec..645a3db64b 100644
--- a/src/image/SkImage_Raster.cpp
+++ b/src/image/SkImage_Raster.cpp
@@ -254,7 +254,7 @@ sk_sp<SkImage> SkMakeImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr,
     return sk_make_sp<SkImage_Raster>(info, pr, pixelRefOrigin, rowBytes);
 }
 
-sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy) {
+sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, SkCopyPixelsMode cpm) {
     bool hasColorTable = false;
     if (kIndex_8_SkColorType == bm.colorType()) {
         SkAutoLockPixels autoLockPixels(bm);
@@ -266,9 +266,7 @@ sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode for
     }
 
     sk_sp<SkImage> image;
-    if (kYes_ForceCopyMode == forceCopy ||
-        (!bm.isImmutable() && kNever_ForceCopyMode != forceCopy))
-    {
+    if (kAlways_SkCopyPixelsMode == cpm || (!bm.isImmutable() && kNever_SkCopyPixelsMode != cpm)) {
         SkBitmap tmp(bm);
         tmp.lockPixels();
         SkPixmap pmap;
@@ -276,7 +274,7 @@ sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode for
             image = SkImage::MakeRasterCopy(pmap);
         }
     } else {
-        image = sk_make_sp<SkImage_Raster>(bm, kNever_ForceCopyMode == forceCopy);
+        image = sk_make_sp<SkImage_Raster>(bm, kNever_SkCopyPixelsMode == cpm);
     }
     return image;
 }
diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h
index 7164c884e0..8351bb87e6 100644
--- a/src/image/SkSurface_Base.h
+++ b/src/image/SkSurface_Base.h
@@ -43,7 +43,7 @@ public:
      *  must faithfully represent the current contents, even if the surface
      *  is changed after this called (e.g. it is drawn to via its canvas).
      */
-    virtual sk_sp<SkImage> onNewImageSnapshot(SkBudgeted, ForceCopyMode) = 0;
+    virtual sk_sp<SkImage> onNewImageSnapshot(SkBudgeted, SkCopyPixelsMode) = 0;
 
     /**
      *  Default implementation:
@@ -122,9 +122,9 @@ sk_sp<SkImage> SkSurface_Base::refCachedImage(SkBudgeted budgeted, ForceUnique u
     if (snap) {
         return sk_ref_sp(snap);
     }
-    ForceCopyMode fcm = (kYes_ForceUnique == unique) ? kYes_ForceCopyMode :
-                                                       kNo_ForceCopyMode;
-    snap = this->onNewImageSnapshot(budgeted, fcm).release();
+    SkCopyPixelsMode cpm = (kYes_ForceUnique == unique) ? kAlways_SkCopyPixelsMode :
+                                                          kIfMutable_SkCopyPixelsMode;
+    snap = this->onNewImageSnapshot(budgeted, cpm).release();
     if (kNo_ForceUnique == unique) {
         SkASSERT(!fCachedImage);
         fCachedImage = SkSafeRef(snap);
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index 800cf477e3..1d715705c7 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -75,7 +75,7 @@ sk_sp<SkSurface> SkSurface_Gpu::onNewSurface(const SkImageInfo& info) {
                                        origin, &this->props());
 }
 
-sk_sp<SkImage> SkSurface_Gpu::onNewImageSnapshot(SkBudgeted budgeted, ForceCopyMode forceCopyMode) {
+sk_sp<SkImage> SkSurface_Gpu::onNewImageSnapshot(SkBudgeted budgeted, SkCopyPixelsMode cpm) {
     GrRenderTarget* rt = fDevice->accessDrawContext()->accessRenderTarget();
     SkASSERT(rt);
     GrTexture* tex = rt->asTexture();
@@ -83,7 +83,7 @@ sk_sp<SkImage> SkSurface_Gpu::onNewImageSnapshot(SkBudgeted budgeted, ForceCopyM
     // If the original render target is a buffer originally created by the client, then we don't
     // want to ever retarget the SkSurface at another buffer we create. Force a copy now to avoid
     // copy-on-write.
-    if (kYes_ForceCopyMode == forceCopyMode || !tex || rt->resourcePriv().refsWrappedObjects()) {
+    if (kAlways_SkCopyPixelsMode == cpm || !tex || rt->resourcePriv().refsWrappedObjects()) {
         GrSurfaceDesc desc = fDevice->accessDrawContext()->desc();
         GrContext* ctx = fDevice->context();
         desc.fFlags = desc.fFlags & ~kRenderTarget_GrSurfaceFlag;
diff --git a/src/image/SkSurface_Gpu.h b/src/image/SkSurface_Gpu.h
index d0f195902a..8432d9f94c 100644
--- a/src/image/SkSurface_Gpu.h
+++ b/src/image/SkSurface_Gpu.h
@@ -23,7 +23,7 @@ public:
     bool onGetRenderTargetHandle(GrBackendObject*, BackendHandleAccess) override;
     SkCanvas* onNewCanvas() override;
     sk_sp<SkSurface> onNewSurface(const SkImageInfo&) override;
-    sk_sp<SkImage> onNewImageSnapshot(SkBudgeted, ForceCopyMode) override;
+    sk_sp<SkImage> onNewImageSnapshot(SkBudgeted, SkCopyPixelsMode) override;
     void onCopyOnWrite(ContentChangeMode) override;
     void onDiscard() override;
     void onPrepareForExternalIO() override;
diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp
index c1be0b7fc5..90f26becb2 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -24,7 +24,7 @@ public:
 
     SkCanvas* onNewCanvas() override;
     sk_sp<SkSurface> onNewSurface(const SkImageInfo&) override;
-    sk_sp<SkImage> onNewImageSnapshot(SkBudgeted, ForceCopyMode) override;
+    sk_sp<SkImage> onNewImageSnapshot(SkBudgeted, SkCopyPixelsMode) override;
     void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) override;
     void onCopyOnWrite(ContentChangeMode) override;
     void onRestoreBackingMutability() override;
@@ -118,7 +118,7 @@ void SkSurface_Raster::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y,
     canvas->drawBitmap(fBitmap, x, y, paint);
 }
 
-sk_sp<SkImage> SkSurface_Raster::onNewImageSnapshot(SkBudgeted, ForceCopyMode forceCopyMode) {
+sk_sp<SkImage> SkSurface_Raster::onNewImageSnapshot(SkBudgeted, SkCopyPixelsMode cpm) {
     if (fWeOwnThePixels) {
         // SkImage_raster requires these pixels are immutable for its full lifetime.
         // We'll undo this via onRestoreBackingMutability() if we can avoid the COW.
@@ -126,12 +126,12 @@ sk_sp<SkImage> SkSurface_Raster::onNewImageSnapshot(SkBudgeted, ForceCopyMode fo
             pr->setTemporarilyImmutable();
         }
     } else {
-        forceCopyMode = kYes_ForceCopyMode;
+        cpm = kAlways_SkCopyPixelsMode;
     }
 
     // Our pixels are in memory, so read access on the snapshot SkImage could be cheap.
     // Lock the shared pixel ref to ensure peekPixels() is usable.
-    return SkMakeImageFromRasterBitmap(fBitmap, forceCopyMode);
+    return SkMakeImageFromRasterBitmap(fBitmap, cpm);
 }
 
 void SkSurface_Raster::onRestoreBackingMutability() {
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 671c479816..14b55a421a 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -194,20 +194,20 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, ctxInfo) {
 
 DEF_TEST(Image_MakeFromRasterBitmap, reporter) {
     const struct {
-        ForceCopyMode fMode;
-        bool          fExpectSameAsMutable;
-        bool          fExpectSameAsImmutable;
+        SkCopyPixelsMode fCPM;
+        bool            fExpectSameAsMutable;
+        bool            fExpectSameAsImmutable;
     } recs[] = {
-        { kNo_ForceCopyMode,    false,  true },
-        { kYes_ForceCopyMode,   false,  false },
-        { kNever_ForceCopyMode, true,   true },
+        { kIfMutable_SkCopyPixelsMode,  false,  true },
+        { kAlways_SkCopyPixelsMode,     false,  false },
+        { kNever_SkCopyPixelsMode,      true,   true },
     };
     for (auto rec : recs) {
         SkPixmap pm;
         SkBitmap bm;
         bm.allocN32Pixels(100, 100);
 
-        auto img = SkMakeImageFromRasterBitmap(bm, rec.fMode);
+        auto img = SkMakeImageFromRasterBitmap(bm, rec.fCPM);
         REPORTER_ASSERT(reporter, img->peekPixels(&pm));
         const bool sameMutable = pm.addr32(0, 0) == bm.getAddr32(0, 0);
         REPORTER_ASSERT(reporter, rec.fExpectSameAsMutable == sameMutable);
@@ -215,7 +215,7 @@ DEF_TEST(Image_MakeFromRasterBitmap, reporter) {
         bm.notifyPixelsChanged();   // force a new generation ID
 
         bm.setImmutable();
-        img = SkMakeImageFromRasterBitmap(bm, rec.fMode);
+        img = SkMakeImageFromRasterBitmap(bm, rec.fCPM);
         REPORTER_ASSERT(reporter, img->peekPixels(&pm));
         const bool sameImmutable = pm.addr32(0, 0) == bm.getAddr32(0, 0);
         REPORTER_ASSERT(reporter, rec.fExpectSameAsImmutable == sameImmutable);
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 0e53ac6009..86591b5d28 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -7,7 +7,6 @@
 
 #include "Resources.h"
 #include "SkAnnotationKeys.h"
-#include "SkBitmapProcShader.h"
 #include "SkCanvas.h"
 #include "SkFixed.h"
 #include "SkFontDescriptor.h"
@@ -581,12 +580,12 @@ DEF_TEST(Serialization, reporter) {
         normals.allocN32Pixels(kTexSize, kTexSize);
 
         sk_tool_utils::create_frustum_normal_map(&normals, SkIRect::MakeWH(kTexSize, kTexSize));
-        sk_sp<SkShader> normalMap = SkMakeBitmapShader(normals, SkShader::kClamp_TileMode,
-                                                       SkShader::kClamp_TileMode, &matrix, nullptr);
+        sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normals, SkShader::kClamp_TileMode,
+                SkShader::kClamp_TileMode, &matrix);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
                                                                                ctm);
-        sk_sp<SkShader> diffuseShader = SkMakeBitmapShader(diffuse, SkShader::kClamp_TileMode,
-                SkShader::kClamp_TileMode, &matrix, nullptr);
+        sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(diffuse,
+                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
 
         sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuseShader,
                                                                 normalSource,