SkPDF: clean up uses of deprecated calls in other SkPDF classes

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 583 matching lines @@
                                          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->insertObject("BBox", SkPDFUtils::RectToArray(bbox));
     pattern->insertScalar("XStep", bbox.width());
     pattern->insertScalar("YStep", bbox.height());
-    pattern->insert("Resources", resources);
+    pattern->insertObject("Resources", SkRef(resources));
     if (!matrix.isIdentity()) {
-        pattern->insert("Matrix", SkPDFUtils::MatrixToArray(matrix))->unref();
+        pattern->insertObject("Matrix", SkPDFUtils::MatrixToArray(matrix));
     }
 }
 
 /**
  * Creates a content stream which fills the pattern P0 across bounds.
  * @param gsIndex A graphics state resource index to apply, or <0 if no
  * graphics state to apply.
  */
 static SkStream* create_pattern_fill_content(int gsIndex, SkRect& bounds) {
     SkDynamicMemoryWStream content;
@@ skipping 128 matching lines @@
 
 SK_DECLARE_STATIC_LAZY_PTR(SkPDFObject, rangeObject,
                            create_range_object, unref<SkPDFObject>);
 
 static SkPDFStream* make_ps_function(const SkString& psCode,
                                      SkPDFArray* domain) {
     SkAutoDataUnref funcData(
             SkData::NewWithCopy(psCode.c_str(), psCode.size()));
     SkPDFStream* result = SkNEW_ARGS(SkPDFStream, (funcData.get()));
     result->insertInt("FunctionType", 4);
-    result->insert("Domain", domain);
-    result->insert("Range", rangeObject.get());
+    result->insertObject("Domain", SkRef(domain));
+    result->insertObject("Range", SkRef(rangeObject.get()));
     return result;
 }
 
 SkPDFFunctionShader* SkPDFFunctionShader::Create(
         SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
     SkString (*codeFunction)(const SkShader::GradientInfo& info,
                              const SkMatrix& perspectiveRemover) = NULL;
     SkPoint transformPoints[2];
@@ skipping 94 matching lines @@
         twoPointRadialInfo.fRadius[1] =
             inverseMapperMatrix.mapRadius(info->fRadius[1]);
         functionCode = codeFunction(twoPointRadialInfo, perspectiveInverseOnly);
     } else {
         functionCode = codeFunction(*info, perspectiveInverseOnly);
     }
 
     SkAutoTUnref<SkPDFDict> pdfShader(new SkPDFDict);
     pdfShader->insertInt("ShadingType", 1);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
-    pdfShader->insert("Domain", domain.get());
+    pdfShader->insertObject("Domain", SkRef(domain.get()));
 
     SkAutoTUnref<SkPDFStream> function(
             make_ps_function(functionCode, domain.get()));
-    pdfShader->insert("Function", new SkPDFObjRef(function))->unref();
-
-    SkAutoTUnref<SkPDFArray> matrixArray(
-            SkPDFUtils::MatrixToArray(finalMatrix));
+    pdfShader->insertObjRef("Function", function.detach());
 
     SkPDFFunctionShader* pdfFunctionShader =
             SkNEW_ARGS(SkPDFFunctionShader, (autoState->detach()));
 
     pdfFunctionShader->insertInt("PatternType", 2);
-    pdfFunctionShader->insert("Matrix", matrixArray.get());
-    pdfFunctionShader->insert("Shading", pdfShader.get());
+    pdfFunctionShader->insertObject("Matrix",
+                                    SkPDFUtils::MatrixToArray(finalMatrix));
+    pdfFunctionShader->insertObject("Shading", pdfShader.detach());
 
     canon->addFunctionShader(pdfFunctionShader);
     return pdfFunctionShader;
 }
 
 SkPDFImageShader* SkPDFImageShader::Create(
         SkPDFCanon* canon,
         SkScalar dpi,
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
@@ skipping 401 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);
 }