SkPDF: properly dedup bitmaps in shaders

src/pdf/SkPDFShader.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
 
@@ skipping 412 matching lines @@
 class SkPDFShader::State {
 public:
     SkShader::GradientType fType;
     SkShader::GradientInfo fInfo;
     SkAutoFree fColorData;    // This provides storage for arrays in fInfo.
     SkMatrix fCanvasTransform;
     SkMatrix fShaderTransform;
     SkIRect fBBox;
 
     SkBitmap fImage;
-    uint32_t fPixelGeneration;
+    SkBitmapKey fBitmapKey;
     SkShader::TileMode fImageTileModes[2];
 
     State(SkShader* shader, const SkMatrix& canvasTransform,
           const SkIRect& bbox, SkScalar rasterScale);
 
     bool operator==(const State& b) const;
 
     SkPDFShader::State* CreateAlphaToLuminosityState() const;
     SkPDFShader::State* CreateOpaqueState() const;
 
@@ skipping 595 matching lines @@
 
 bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
     if (fType != b.fType ||
             fCanvasTransform != b.fCanvasTransform ||
             fShaderTransform != b.fShaderTransform ||
             fBBox != b.fBBox) {
         return false;
     }
 
     if (fType == SkShader::kNone_GradientType) {
-        if (fPixelGeneration != b.fPixelGeneration ||
-                fPixelGeneration == 0 ||
+        if (fBitmapKey != b.fBitmapKey ||
+                fBitmapKey.id() == 0 ||
                 fImageTileModes[0] != b.fImageTileModes[0] ||
                 fImageTileModes[1] != b.fImageTileModes[1]) {
             return false;
         }
     } else {
         if (fInfo.fColorCount != b.fInfo.fColorCount ||
                 memcmp(fInfo.fColors, b.fInfo.fColors,
                        sizeof(SkColor) * fInfo.fColorCount) != 0 ||
                 memcmp(fInfo.fColorOffsets, b.fInfo.fColorOffsets,
                        sizeof(SkScalar) * fInfo.fColorCount) != 0 ||
@@ skipping 25 matching lines @@
             case SkShader::kColor_GradientType:
                 break;
         }
     }
     return true;
 }
 
 SkPDFShader::State::State(SkShader* shader, const SkMatrix& canvasTransform,
                           const SkIRect& bbox, SkScalar rasterScale)
         : fCanvasTransform(canvasTransform),
-          fBBox(bbox),
-          fPixelGeneration(0) {
+          fBBox(bbox) {
     fInfo.fColorCount = 0;
     fInfo.fColors = nullptr;
     fInfo.fColorOffsets = nullptr;
     fShaderTransform = shader->getLocalMatrix();
     fImageTileModes[0] = fImageTileModes[1] = SkShader::kClamp_TileMode;
 
     fType = shader->asAGradient(&fInfo);
 
     if (fType == SkShader::kNone_GradientType) {
         SkMatrix matrix;
@@ skipping 33 matching lines @@
             p.setShader(sk_ref_sp(shader));
 
             SkCanvas canvas(fImage);
             canvas.scale(scale.width(), scale.height());
             canvas.translate(-shaderRect.x(), -shaderRect.y());
             canvas.drawPaint(p);
 
             fShaderTransform.setTranslate(shaderRect.x(), shaderRect.y());
             fShaderTransform.preScale(1 / scale.width(), 1 / scale.height());
         }
-        fPixelGeneration = fImage.getGenerationID();
+        fBitmapKey = SkBitmapKey(fImage);
     } else {
         AllocateGradientInfoStorage();
         shader->asAGradient(&fInfo);
     }
 }
 
 SkPDFShader::State::State(const SkPDFShader::State& other)
   : fType(other.fType),
     fCanvasTransform(other.fCanvasTransform),
     fShaderTransform(other.fShaderTransform),
@@ skipping 64 matching lines @@
     return false;
 }
 
 void SkPDFShader::State::AllocateGradientInfoStorage() {
     fColorData.set(sk_malloc_throw(
                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
     fInfo.fColorOffsets =
             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
 }