SkPDF: Change some identifiers.

    s/SkPDFShader::GetPDFShader/SkPDFMakeShader/g
    s/SkPDFShader::State/SkPDFImageShaderKey/g
    s/state/key/g

Change-Id: I86dc932c3407c73f387c972fb6674dc09ea0be3c
Reviewed-on: https://skia-review.googlesource.com/21661
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Hal Canary <halcanary@google.com>

4 files changed, 56 insertions, 63 deletions

diff --git a/src/pdf/SkPDFCanon.h b/src/pdf/SkPDFCanon.h
index 41b19eefa4..03671bf921 100644
--- a/src/pdf/SkPDFCanon.h
+++ b/src/pdf/SkPDFCanon.h
@@ -29,7 +29,7 @@ public:
     SkPDFCanon(const SkPDFCanon&) = delete;
     SkPDFCanon& operator=(const SkPDFCanon&) = delete;
 
-    SkTHashMap<SkPDFShader::State, sk_sp<SkPDFObject>> fImageShaderMap;
+    SkTHashMap<SkPDFImageShaderKey, sk_sp<SkPDFObject>> fImageShaderMap;
 
     SkPDFGradientShader::HashMap fGradientPatternMap;
 
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 6888f54ca5..b744a524f6 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -2174,7 +2174,7 @@ void SkPDFDevice::populateGraphicStateEntryFromPaint(
             SkIRect bounds;
             clipStackBounds.roundOut(&bounds);
 
-            pdfShader = SkPDFShader::GetPDFShader(fDocument, shader, transform, bounds);
+            pdfShader = SkPDFMakeShader(fDocument, shader, transform, bounds);
 
             if (pdfShader.get()) {
                 // pdfShader has been canonicalized so we can directly compare
diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp
index 44cc27b0a9..56d42f68e9 100644
--- a/src/pdf/SkPDFShader.cpp
+++ b/src/pdf/SkPDFShader.cpp
@@ -29,9 +29,9 @@ static void draw_bitmap_matrix(SkCanvas* canvas, const SkBitmap& bm, const SkMat
 }
 
 static sk_sp<SkPDFStream> make_image_shader(SkPDFDocument* doc,
-                                            const SkPDFShader::State& state,
+                                            const SkPDFImageShaderKey& key,
                                             SkBitmap image) {
-    SkASSERT(state.fBitmapKey ==
+    SkASSERT(key.fBitmapKey ==
              (SkBitmapKey{image.getSubset(), image.getGenerationID()}));
 
     // The image shader pattern cell will be drawn into a separate device
@@ -40,10 +40,10 @@ static sk_sp<SkPDFStream> make_image_shader(SkPDFDocument* doc,
 
     // Map clip bounds to shader space to ensure the device is large enough
     // to handle fake clamping.
-    SkMatrix finalMatrix = state.fCanvasTransform;
-    finalMatrix.preConcat(state.fShaderTransform);
+    SkMatrix finalMatrix = key.fCanvasTransform;
+    finalMatrix.preConcat(key.fShaderTransform);
     SkRect deviceBounds;
-    deviceBounds.set(state.fBBox);
+    deviceBounds.set(key.fBBox);
     if (!SkPDFUtils::InverseTransformBBox(finalMatrix, &deviceBounds)) {
         return nullptr;
     }
@@ -56,8 +56,8 @@ static sk_sp<SkPDFStream> make_image_shader(SkPDFDocument* doc,
     // For clamp modes, we're only interested in the clip region, whether
     // or not the main bitmap is in it.
     SkShader::TileMode tileModes[2];
-    tileModes[0] = state.fImageTileModes[0];
-    tileModes[1] = state.fImageTileModes[1];
+    tileModes[0] = key.fImageTileModes[0];
+    tileModes[1] = key.fImageTileModes[1];
     if (tileModes[0] != SkShader::kClamp_TileMode ||
             tileModes[1] != SkShader::kClamp_TileMode) {
         deviceBounds.join(bitmapBounds);
@@ -241,14 +241,14 @@ static sk_sp<SkPDFObject> make_fallback_shader(SkPDFDocument* doc,
     // handle compose shader by pulling things up to a layer, drawing with
     // the first shader, applying the xfer mode and drawing again with the
     // second shader, then applying the layer to the original drawing.
-    SkPDFShader::State state = {
+    SkPDFImageShaderKey key = {
         canvasTransform,
         SkMatrix::I(),
         surfaceBBox,
         {{0, 0, 0, 0}, 0},
         {SkShader::kClamp_TileMode, SkShader::kClamp_TileMode}};
 
-    state.fShaderTransform = shader->getLocalMatrix();
+    key.fShaderTransform = shader->getLocalMatrix();
 
     // surfaceBBox is in device space. While that's exactly what we
     // want for sizing our bitmap, we need to map it into
@@ -283,17 +283,17 @@ static sk_sp<SkPDFObject> make_fallback_shader(SkPDFDocument* doc,
     canvas.translate(-shaderRect.x(), -shaderRect.y());
     canvas.drawPaint(p);
 
-    state.fShaderTransform.setTranslate(shaderRect.x(), shaderRect.y());
-    state.fShaderTransform.preScale(1 / scale.width(), 1 / scale.height());
-    state.fBitmapKey = SkBitmapKey{image.getSubset(), image.getGenerationID()};
+    key.fShaderTransform.setTranslate(shaderRect.x(), shaderRect.y());
+    key.fShaderTransform.preScale(1 / scale.width(), 1 / scale.height());
+    key.fBitmapKey = SkBitmapKey{image.getSubset(), image.getGenerationID()};
     SkASSERT (!image.isNull());
-    return make_image_shader(doc, state, std::move(image));
+    return make_image_shader(doc, key, std::move(image));
 }
 
-sk_sp<SkPDFObject> SkPDFShader::GetPDFShader(SkPDFDocument* doc,
-                                             SkShader* shader,
-                                             const SkMatrix& canvasTransform,
-                                             const SkIRect& surfaceBBox) {
+sk_sp<SkPDFObject> SkPDFMakeShader(SkPDFDocument* doc,
+                                  SkShader* shader,
+                                  const SkMatrix& canvasTransform,
+                                  const SkIRect& surfaceBBox) {
     SkASSERT(shader);
     SkASSERT(doc);
     if (SkShader::kNone_GradientType != shader->asAGradient(nullptr)) {
@@ -303,7 +303,7 @@ sk_sp<SkPDFObject> SkPDFShader::GetPDFShader(SkPDFDocument* doc,
         return nullptr;
     }
     SkBitmap image;
-    SkPDFShader::State state = {
+    SkPDFImageShaderKey key = {
         canvasTransform,
         SkMatrix::I(),
         surfaceBBox,
@@ -312,20 +312,20 @@ sk_sp<SkPDFObject> SkPDFShader::GetPDFShader(SkPDFDocument* doc,
 
     SkASSERT(shader->asAGradient(nullptr) == SkShader::kNone_GradientType) ;
     SkImage* skimg;
-    if ((skimg = shader->isAImage(&state.fShaderTransform, state.fImageTileModes))
+    if ((skimg = shader->isAImage(&key.fShaderTransform, key.fImageTileModes))
             && skimg->asLegacyBitmap(&image, SkImage::kRO_LegacyBitmapMode)) {
         // TODO(halcanary): delay converting to bitmap.
-        state.fBitmapKey = SkBitmapKey{image.getSubset(), image.getGenerationID()};
+        key.fBitmapKey = SkBitmapKey{image.getSubset(), image.getGenerationID()};
         if (image.isNull()) {
             return nullptr;
         }
         SkPDFCanon* canon = doc->canon();
-        sk_sp<SkPDFObject>* shaderPtr = canon->fImageShaderMap.find(state);
+        sk_sp<SkPDFObject>* shaderPtr = canon->fImageShaderMap.find(key);
         if (shaderPtr) {
             return *shaderPtr;
         }
-        sk_sp<SkPDFObject> pdfShader = make_image_shader(doc, state, std::move(image));
-        canon->fImageShaderMap.set(std::move(state), pdfShader);
+        sk_sp<SkPDFObject> pdfShader = make_image_shader(doc, key, std::move(image));
+        canon->fImageShaderMap.set(std::move(key), pdfShader);
         return pdfShader;
     }
     // Don't bother to de-dup fallback shader.
diff --git a/src/pdf/SkPDFShader.h b/src/pdf/SkPDFShader.h
index 062aaa67e6..09e7738e30 100644
--- a/src/pdf/SkPDFShader.h
+++ b/src/pdf/SkPDFShader.h
@@ -18,45 +18,39 @@ class SkPDFDocument;
 class SkMatrix;
 struct SkIRect;
 
-/** \class SkPDFShader
-
-    In PDF parlance, this is a pattern, used in place of a color when the
-    pattern color space is selected.
-*/
-
-class SkPDFShader {
-public:
-    /** Get the PDF shader for the passed SkShader. If the SkShader is
-     *  invalid in some way, returns nullptr. The reference count of
-     *  the object is incremented and it is the caller's responsibility to
-     *  unreference it when done.  This is needed to accommodate the weak
-     *  reference pattern used when the returned object is new and has no
-     *  other references.
-     *  @param shader      The SkShader to emulate.
-     *  @param matrix      The current transform. (PDF shaders are absolutely
-     *                     positioned, relative to where the page is drawn.)
-     *  @param surfceBBox  The bounding box of the drawing surface (with matrix
-     *                     already applied).
-     */
-    static sk_sp<SkPDFObject> GetPDFShader(SkPDFDocument* doc,
-                                           SkShader* shader,
-                                           const SkMatrix& matrix,
-                                           const SkIRect& surfaceBBox);
-
-    static sk_sp<SkPDFArray> MakeRangeObject();
-
-    SK_BEGIN_REQUIRE_DENSE
-    struct State {
-        SkMatrix fCanvasTransform;
-        SkMatrix fShaderTransform;
-        SkIRect fBBox;
-        SkBitmapKey fBitmapKey;
-        SkShader::TileMode fImageTileModes[2];
-    };
-    SK_END_REQUIRE_DENSE
+/** Make a PDF shader for the passed SkShader. If the SkShader is invalid in
+ *  some way, returns nullptr.
+ *
+ *  In PDF parlance, this is a pattern, used in place of a color when the
+ *  pattern color space is selected.
+ *
+ *  May cache the shader in the document for later re-use.  If this function is
+ *  called again with an equivalent shader,  a new reference to the cached pdf
+ *  shader may be returned.
+ *
+ *  @param doc         The parent document, must be non-null.
+ *  @param shader      The SkShader to emulate.
+ *  @param ctm         The current transform matrix. (PDF shaders are absolutely
+ *                     positioned, relative to where the page is drawn.)
+ *  @param surfceBBox  The bounding box of the drawing surface (with matrix
+ *                     already applied).
+ */
+sk_sp<SkPDFObject> SkPDFMakeShader(SkPDFDocument* doc,
+                                  SkShader* shader,
+                                  const SkMatrix& ctm,
+                                  const SkIRect& surfaceBBox);
+
+SK_BEGIN_REQUIRE_DENSE
+struct SkPDFImageShaderKey {
+    SkMatrix fCanvasTransform;
+    SkMatrix fShaderTransform;
+    SkIRect fBBox;
+    SkBitmapKey fBitmapKey;
+    SkShader::TileMode fImageTileModes[2];
 };
+SK_END_REQUIRE_DENSE
 
-inline bool operator==(const SkPDFShader::State& a, const SkPDFShader::State& b) {
+inline bool operator==(const SkPDFImageShaderKey& a, const SkPDFImageShaderKey& b) {
     SkASSERT(a.fBitmapKey.fID != 0);
     SkASSERT(b.fBitmapKey.fID != 0);
     return a.fCanvasTransform   == b.fCanvasTransform
@@ -66,5 +60,4 @@ inline bool operator==(const SkPDFShader::State& a, const SkPDFShader::State& b)
         && a.fImageTileModes[0] == b.fImageTileModes[0]
         && a.fImageTileModes[1] == b.fImageTileModes[1];
 }
-
 #endif