SkPDF: remove all globally references SkPDFObjects

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 "SkOncePtr.h"
 #include "SkPDFCanon.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 "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 539 matching lines @@
     SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kEvenOdd_FillType,
                           &content);
 
     return content.detachAsStream();
 }
 
 /**
  * Creates a ExtGState with the SMask set to the luminosityShader in
  * luminosity mode. The shader pattern extends to the bbox.
  */
-static SkPDFObject* create_smask_graphic_state(
+static sk_sp<SkPDFObject> create_smask_graphic_state(
         SkPDFCanon* canon, SkScalar dpi, const SkPDFShader::State& state) {
     SkRect bbox;
     bbox.set(state.fBBox);
 
     SkAutoTDelete<SkPDFShader::State> alphaToLuminosityState(
             state.CreateAlphaToLuminosityState());
     sk_sp<SkPDFObject> luminosityShader(
             get_pdf_shader_by_state(canon, dpi, &alphaToLuminosityState));
 
     SkAutoTDelete<SkStream> alphaStream(create_pattern_fill_content(-1, bbox));
 
     auto resources =
         get_gradient_resource_dict(luminosityShader.get(), nullptr);
 
     sk_sp<SkPDFFormXObject> alphaMask(
             new SkPDFFormXObject(alphaStream.get(), bbox, resources.get()));
 
     return SkPDFGraphicState::GetSMaskGraphicState(
             alphaMask.get(), false,
-            SkPDFGraphicState::kLuminosity_SMaskMode);
+            SkPDFGraphicState::kLuminosity_SMaskMode, canon);
 }
 
 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());
 
     sk_sp<SkPDFObject> colorShader(
             get_pdf_shader_by_state(canon, dpi, &opaqueState));
     if (!colorShader) {
         return nullptr;
     }
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
-    sk_sp<SkPDFObject> alphaGs(
-            create_smask_graphic_state(canon, dpi, state));
+    auto alphaGs = create_smask_graphic_state(canon, dpi, state);
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
             new SkPDFAlphaFunctionShader(autoState->detach());
 
     auto resourceDict =
             get_gradient_resource_dict(colorShader.get(), alphaGs.get());
 
     SkAutoTDelete<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     alphaFunctionShader->setData(colorStream.get());
@@ skipping 35 matching lines @@
                                zero,         one,        zero,
                                -p0/p2,     -p1/p2,     1/p2);
 
     affine->setAll(sx - p0 * tx / p2,       kx - p1 * tx / p2,      tx / p2,
                    ky - p0 * ty / p2,       sy - p1 * ty / p2,      ty / p2,
                    zero,                    zero,                   one);
 
     return true;
 }
 
-static SkPDFObject* create_range_object() {
-    SkPDFArray* range = new SkPDFArray;
+sk_sp<SkPDFArray> SkPDFShader::MakeRangeObject() {
+    auto range = sk_make_sp<SkPDFArray>();
     range->reserve(6);
     range->appendInt(0);
     range->appendInt(1);
     range->appendInt(0);
     range->appendInt(1);
     range->appendInt(0);
     range->appendInt(1);
     return range;
 }
-SK_DECLARE_STATIC_ONCE_PTR(SkPDFObject, rangeObject);
 
-static SkPDFStream* make_ps_function(const SkString& psCode,
-                                     SkPDFArray* domain) {
+static sk_sp<SkPDFStream> make_ps_function(const SkString& psCode,
+                                           SkPDFArray* domain,
+                                           sk_sp<SkPDFObject> range) {
     SkAutoDataUnref funcData(
             SkData::NewWithCopy(psCode.c_str(), psCode.size()));
-    SkPDFStream* result = new SkPDFStream(funcData.get());
+    auto result = sk_make_sp<SkPDFStream>(funcData.get());
     result->insertInt("FunctionType", 4);
     result->insertObject("Domain", sk_ref_sp(domain));
-    result->insertObject("Range", sk_ref_sp(rangeObject.get(create_range_object)));
+    result->insertObject("Range", std::move(range));
     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) = nullptr;
     SkPoint transformPoints[2];
@@ skipping 85 matching lines @@
         functionCode = codeFunction(twoPointRadialInfo, perspectiveInverseOnly);
     } else {
         functionCode = codeFunction(*info, perspectiveInverseOnly);
     }
 
     auto pdfShader = sk_make_sp<SkPDFDict>();
     pdfShader->insertInt("ShadingType", 1);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
     pdfShader->insertObject("Domain", sk_ref_sp(domain.get()));
 
-    sk_sp<SkPDFStream> function(
-            make_ps_function(functionCode, domain.get()));
+    // Call canon->makeRangeObject() instead of
+    // SkPDFShader::MakeRangeObject() so that the canon can
+    // deduplicate.
+    auto function = make_ps_function(functionCode, domain.get(),
+        canon->makeRangeObject());
     pdfShader->insertObjRef("Function", std::move(function));
 
     sk_sp<SkPDFFunctionShader> pdfFunctionShader(
             new SkPDFFunctionShader(autoState->detach()));
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insertObject("Matrix",
                                     SkPDFUtils::MatrixToArray(finalMatrix));
     pdfFunctionShader->insertObject("Shading", std::move(pdfShader));
 
     canon->addFunctionShader(pdfFunctionShader.get());
@@ skipping 404 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);
 }