move setshader to sk_sp

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 416 matching lines @@
     SkShader::GradientInfo fInfo;
     SkAutoFree fColorData;    // This provides storage for arrays in fInfo.
     SkMatrix fCanvasTransform;
     SkMatrix fShaderTransform;
     SkIRect fBBox;
 
     SkBitmap fImage;
     uint32_t fPixelGeneration;
     SkShader::TileMode fImageTileModes[2];
 
-    State(const SkShader& shader, const SkMatrix& canvasTransform,
+    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;
 
     bool GradientHasAlpha() const;
 
 private:
@@ skipping 60 matching lines @@
     } else {
         SkPDFObject* shader = canon->findFunctionShader(state);
         return shader ? SkRef(shader)
                       : SkPDFFunctionShader::Create(canon, autoState);
     }
 }
 
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(SkPDFDocument* doc,
                                        SkScalar dpi,
-                                       const SkShader& shader,
+                                       SkShader* shader,
                                        const SkMatrix& matrix,
                                        const SkIRect& surfaceBBox,
                                        SkScalar rasterScale) {
     SkAutoTDelete<SkPDFShader::State> state(new State(shader, matrix, surfaceBBox, rasterScale));
     return get_pdf_shader_by_state(doc, dpi, &state);
 }
 
 static sk_sp<SkPDFDict> get_gradient_resource_dict(
         SkPDFObject* functionShader,
         SkPDFObject* gState) {
@@ skipping 555 matching lines @@
                 break;
             case SkShader::kSweep_GradientType:
             case SkShader::kNone_GradientType:
             case SkShader::kColor_GradientType:
                 break;
         }
     }
     return true;
 }
 
-SkPDFShader::State::State(const SkShader& shader, const SkMatrix& canvasTransform,
+SkPDFShader::State::State(SkShader* shader, const SkMatrix& canvasTransform,
                           const SkIRect& bbox, SkScalar rasterScale)
         : fCanvasTransform(canvasTransform),
           fBBox(bbox),
           fPixelGeneration(0) {
     fInfo.fColorCount = 0;
     fInfo.fColors = nullptr;
     fInfo.fColorOffsets = nullptr;
-    fShaderTransform = shader.getLocalMatrix();
+    fShaderTransform = shader->getLocalMatrix();
     fImageTileModes[0] = fImageTileModes[1] = SkShader::kClamp_TileMode;
 
-    fType = shader.asAGradient(&fInfo);
+    fType = shader->asAGradient(&fInfo);
 
     if (fType == SkShader::kNone_GradientType) {
         SkMatrix matrix;
-        if (shader.isABitmap(&fImage, &matrix, fImageTileModes)) {
+        if (shader->isABitmap(&fImage, &matrix, fImageTileModes)) {
             SkASSERT(matrix.isIdentity());
         } else {
             // Generic fallback for unsupported shaders:
             //  * allocate a bbox-sized bitmap
             //  * shade the whole area
             //  * use the result as a bitmap shader
 
             // bbox is in device space. While that's exactly what we want for sizing our bitmap,
             // we need to map it into shader space for adjustments (to match
             // SkPDFImageShader::Create's behavior).
@@ skipping 12 matching lines @@
 
             SkISize size = SkISize::Make(SkScalarRoundToInt(rasterScale * bbox.width()),
                                          SkScalarRoundToInt(rasterScale * bbox.height()));
             SkSize scale = SkSize::Make(SkIntToScalar(size.width()) / shaderRect.width(),
                                         SkIntToScalar(size.height()) / shaderRect.height());
 
             fImage.allocN32Pixels(size.width(), size.height());
             fImage.eraseColor(SK_ColorTRANSPARENT);
 
             SkPaint p;
-            p.setShader(const_cast<SkShader*>(&shader));
+            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();
     } else {
         AllocateGradientInfoStorage();
-        shader.asAGradient(&fInfo);
+        shader->asAGradient(&fInfo);
     }
 }
 
 SkPDFShader::State::State(const SkPDFShader::State& other)
   : fType(other.fType),
     fCanvasTransform(other.fCanvasTransform),
     fShaderTransform(other.fShaderTransform),
     fBBox(other.fBBox)
 {
     // Only gradients supported for now, since that is all that is used.
@@ skipping 61 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);
 }