PDF: Canon now owns a reference to all interned objects

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 488 matching lines @@
     bool GradientHasAlpha() const;
 
 private:
     State(const State& other);
     State operator=(const State& rhs);
     void AllocateGradientInfoStorage();
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFFunctionShader::SkPDFFunctionShader(SkPDFCanon* canon,
-                                         SkPDFShader::State* state)
-    : SkPDFDict("Pattern"), fCanon(canon), fShaderState(state) {}
+SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
+    : SkPDFDict("Pattern"), fShaderState(state) {}
 
 SkPDFFunctionShader::~SkPDFFunctionShader() {
-    fCanon->removeFunctionShader(this);
     fResources.unrefAll();
 }
 
 bool SkPDFFunctionShader::equals(const SkPDFShader::State& state) const {
     return state == *fShaderState;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFCanon* canon,
-                                                   SkPDFShader::State* state)
-    : fCanon(canon), fShaderState(state) {}
+SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
+    : fShaderState(state) {}
 
 bool SkPDFAlphaFunctionShader::equals(const SkPDFShader::State& state) const {
     return state == *fShaderState;
 }
 
-SkPDFAlphaFunctionShader::~SkPDFAlphaFunctionShader() {
-    fCanon->removeAlphaShader(this);
-}
+SkPDFAlphaFunctionShader::~SkPDFAlphaFunctionShader() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFImageShader::SkPDFImageShader(SkPDFCanon* canon, SkPDFShader::State* state)
-    : fCanon(canon), fShaderState(state) {}
+SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state)
+    : fShaderState(state) {}
 
 bool SkPDFImageShader::equals(const SkPDFShader::State& state) const {
     return state == *fShaderState;
 }
 
 SkPDFImageShader::~SkPDFImageShader() {
-    fCanon->removeImageShader(this);
     fResources.unrefAll();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static SkPDFObject* get_pdf_shader_by_state(
         SkPDFCanon* canon,
         SkScalar dpi,
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
@@ skipping 127 matching lines @@
     if (!colorShader) {
         return NULL;
     }
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
     SkAutoTUnref<SkPDFGraphicState> alphaGs(
             create_smask_graphic_state(canon, dpi, state));
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
-            SkNEW_ARGS(SkPDFAlphaFunctionShader, (canon, autoState->detach()));
+            SkNEW_ARGS(SkPDFAlphaFunctionShader, (autoState->detach()));
 
     alphaFunctionShader->fColorShader.reset(colorShader);
 
     alphaFunctionShader->fResourceDict.reset(get_gradient_resource_dict(
             alphaFunctionShader->fColorShader.get(), alphaGs.get()));
 
     SkAutoTDelete<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     alphaFunctionShader->setData(colorStream.get());
 
@@ skipping 185 matching lines @@
     pdfShader->insertName("ColorSpace", "DeviceRGB");
     pdfShader->insert("Domain", domain.get());
 
     SkPDFStream* function = make_ps_function(functionCode, domain.get());
     pdfShader->insert("Function", new SkPDFObjRef(function))->unref();
 
     SkAutoTUnref<SkPDFArray> matrixArray(
             SkPDFUtils::MatrixToArray(finalMatrix));
 
     SkPDFFunctionShader* pdfFunctionShader =
-            SkNEW_ARGS(SkPDFFunctionShader, (canon, autoState->detach()));
+            SkNEW_ARGS(SkPDFFunctionShader, (autoState->detach()));
 
     pdfFunctionShader->fResources.push(function);
     // Pass ownership to resource list.
 
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insert("Matrix", matrixArray.get());
     pdfFunctionShader->insert("Shading", pdfShader.get());
 
     canon->addFunctionShader(pdfFunctionShader);
     return pdfFunctionShader;
@@ skipping 195 matching lines @@
                 drawBitmapMatrix(&canvas, bottom, bottomMatrix);
             }
             patternBBox.fBottom = deviceBounds.height();
         }
     }
 
     // Put the canvas into the pattern stream (fContent).
     SkAutoTDelete<SkStreamAsset> content(patternDevice->content());
 
     SkPDFImageShader* imageShader =
-            SkNEW_ARGS(SkPDFImageShader, (canon, autoState->detach()));
+            SkNEW_ARGS(SkPDFImageShader, (autoState->detach()));
     imageShader->setData(content.get());
 
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  patternDevice->getResourceDict(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     canon->addImageShader(imageShader);
     return imageShader;
 }
@@ skipping 190 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);
 }