SkPDF: clean up extra references

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"
 
 #include "SkData.h"
 #include "SkPDFCanon.h"
 #include "SkPDFCatalog.h"
 #include "SkPDFDevice.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
 #include "SkPDFResourceDict.h"
 #include "SkPDFUtils.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
-#include "SkTSet.h"
 #include "SkTypes.h"
 
 static bool inverse_transform_bbox(const SkMatrix& matrix, SkRect* bbox) {
     SkMatrix inverse;
     if (!matrix.invert(&inverse)) {
         return false;
     }
     inverse.mapRect(bbox);
     return true;
 }
@@ skipping 468 matching lines @@
     State(const State& other);
     State operator=(const State& rhs);
     void AllocateGradientInfoStorage();
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
     : SkPDFDict("Pattern"), fShaderState(state) {}
 
-SkPDFFunctionShader::~SkPDFFunctionShader() {
-    fResources.unrefAll();
-}
+SkPDFFunctionShader::~SkPDFFunctionShader() {}
 
 bool SkPDFFunctionShader::equals(const SkPDFShader::State& state) const {
     return state == *fShaderState;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
     : fShaderState(state) {}
 
 bool SkPDFAlphaFunctionShader::equals(const SkPDFShader::State& state) const {
     return state == *fShaderState;
 }
 
 SkPDFAlphaFunctionShader::~SkPDFAlphaFunctionShader() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state)
     : fShaderState(state) {}
 
 bool SkPDFImageShader::equals(const SkPDFShader::State& state) const {
     return state == *fShaderState;
 }
 
-SkPDFImageShader::~SkPDFImageShader() {
-    fResources.unrefAll();
-}
+SkPDFImageShader::~SkPDFImageShader() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static SkPDFObject* get_pdf_shader_by_state(
         SkPDFCanon* canon,
         SkScalar dpi,
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
     if (state.fType == SkShader::kNone_GradientType && state.fImage.isNull()) {
         // TODO(vandebo) This drops SKComposeShader on the floor.  We could
@@ skipping 39 matching lines @@
     }
     if (gState != NULL) {
         dict->insertResourceAsReference(
                 SkPDFResourceDict::kExtGState_ResourceType, 0, gState);
     }
 
     return dict;
 }
 
 static void populate_tiling_pattern_dict(SkPDFDict* pattern,
-                                      SkRect& bbox, SkPDFDict* resources,
-                                      const SkMatrix& matrix) {
+                                         SkRect& bbox,
+                                         SkPDFDict* resources,
+                                         const SkMatrix& matrix) {
     const int kTiling_PatternType = 1;
     const int kColoredTilingPattern_PaintType = 1;
     const int kConstantSpacing_TilingType = 1;
 
     pattern->insertName("Type", "Pattern");
     pattern->insertInt("PatternType", kTiling_PatternType);
     pattern->insertInt("PaintType", kColoredTilingPattern_PaintType);
     pattern->insertInt("TilingType", kConstantSpacing_TilingType);
     pattern->insert("BBox", SkPDFUtils::RectToArray(bbox))->unref();
     pattern->insertScalar("XStep", bbox.width());
@@ skipping 52 matching lines @@
 SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(
         SkPDFCanon* canon,
         SkScalar dpi,
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
     SkRect bbox;
     bbox.set(state.fBBox);
 
     SkAutoTDelete<SkPDFShader::State> opaqueState(state.CreateOpaqueState());
 
-    SkPDFObject* colorShader =
-            get_pdf_shader_by_state(canon, dpi, &opaqueState);
+    SkAutoTUnref<SkPDFObject> colorShader(
+            get_pdf_shader_by_state(canon, dpi, &opaqueState));
     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, (autoState->detach()));
 
-    alphaFunctionShader->fColorShader.reset(colorShader);
-
-    alphaFunctionShader->fResourceDict.reset(get_gradient_resource_dict(
-            alphaFunctionShader->fColorShader.get(), alphaGs.get()));
+    SkAutoTUnref<SkPDFResourceDict> resourceDict(
+            get_gradient_resource_dict(colorShader.get(), alphaGs.get()));
 
     SkAutoTDelete<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     alphaFunctionShader->setData(colorStream.get());
 
-    populate_tiling_pattern_dict(alphaFunctionShader, bbox,
-                                 alphaFunctionShader->fResourceDict.get(),
+    populate_tiling_pattern_dict(alphaFunctionShader, bbox, resourceDict.get(),
                                  SkMatrix::I());
     canon->addAlphaShader(alphaFunctionShader);
     return alphaFunctionShader;
 }
 
 // Finds affine and persp such that in = affine * persp.
 // but it returns the inverse of perspective matrix.
 static bool split_perspective(const SkMatrix in, SkMatrix* affine,
                               SkMatrix* perspectiveInverse) {
     const SkScalar p2 = in[SkMatrix::kMPersp2];
@@ skipping 175 matching lines @@
 
     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, (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;
 }
 
 SkPDFImageShader* SkPDFImageShader::Create(
         SkPDFCanon* canon,
@@ skipping 402 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);
 }