SkPDF: Add sk_sp setters; .release() becomes std::move()

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 505 matching lines @@
 SkPDFObject* SkPDFShader::GetPDFShader(SkPDFCanon* canon,
                                        SkScalar dpi,
                                        const 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(canon, dpi, &state);
 }
 
-static SkPDFDict* get_gradient_resource_dict(
+static sk_sp<SkPDFDict> get_gradient_resource_dict(
         SkPDFObject* functionShader,
-        SkPDFObject* gState) {
+        SkPDFObject* gState = nullptr) {

[bungeman-skia, 2016/03/08 19:05:44]

Skia doesn't generally like default parameters if they can be avoided.

[hal.canary, 2016/03/08 19:12:51]

Done.

     SkTDArray<SkPDFObject*> patterns;
     if (functionShader) {
         patterns.push(functionShader);
     }
     SkTDArray<SkPDFObject*> graphicStates;
     if (gState) {
         graphicStates.push(gState);
     }
-    return SkPDFResourceDict::Create(&graphicStates, &patterns, nullptr, nullptr);
+    return SkPDFResourceDict::Make(&graphicStates, &patterns, nullptr, nullptr);
 }
 
 static void populate_tiling_pattern_dict(SkPDFDict* pattern,
                                          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->insertObject("BBox", SkPDFUtils::RectToArray(bbox));
     pattern->insertScalar("XStep", bbox.width());
     pattern->insertScalar("YStep", bbox.height());
-    pattern->insertObject("Resources", SkRef(resources));
+    pattern->insertObject("Resources", sk_sp<SkPDFDict>(SkRef(resources)));
     if (!matrix.isIdentity()) {
         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.
  */
@@ skipping 19 matching lines @@
     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));
 
-    sk_sp<SkPDFDict>
-        resources(get_gradient_resource_dict(luminosityShader.get(), nullptr));
+    auto resources = get_gradient_resource_dict(luminosityShader.get());
 
     sk_sp<SkPDFFormXObject> alphaMask(
             new SkPDFFormXObject(alphaStream.get(), bbox, resources.get()));
 
     return SkPDFGraphicState::GetSMaskGraphicState(
             alphaMask.get(), false,
             SkPDFGraphicState::kLuminosity_SMaskMode);
 }
 
 SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(
@@ skipping 13 matching lines @@
     }
 
     // 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));
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
             new SkPDFAlphaFunctionShader(autoState->detach());
 
-    sk_sp<SkPDFDict> resourceDict(
-            get_gradient_resource_dict(colorShader.get(), alphaGs.get()));
+    auto 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, resourceDict.get(),
                                  SkMatrix::I());
     canon->addAlphaShader(alphaFunctionShader);
     return alphaFunctionShader;
 }
@@ skipping 48 matching lines @@
     return range;
 }
 SK_DECLARE_STATIC_ONCE_PTR(SkPDFObject, rangeObject);
 
 static SkPDFStream* make_ps_function(const SkString& psCode,
                                      SkPDFArray* domain) {
     SkAutoDataUnref funcData(
             SkData::NewWithCopy(psCode.c_str(), psCode.size()));
     SkPDFStream* result = new SkPDFStream(funcData.get());
     result->insertInt("FunctionType", 4);
-    result->insertObject("Domain", SkRef(domain));
-    result->insertObject("Range", SkRef(rangeObject.get(create_range_object)));
+    result->insertObject("Domain", sk_sp<SkPDFObject>(SkRef(domain)));
+    result->insertObject("Range", sk_sp<SkPDFObject>(SkRef(rangeObject.get(create_range_object))));
     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 83 matching lines @@
         twoPointRadialInfo.fRadius[1] =
             inverseMapperMatrix.mapRadius(info->fRadius[1]);
         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", SkRef(domain.get()));
+    pdfShader->insertObject("Domain", sk_sp<SkPDFObject>(SkRef(domain.get())));
 
     sk_sp<SkPDFStream> function(
             make_ps_function(functionCode, domain.get()));
-    pdfShader->insertObjRef("Function", function.release());
+    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", pdfShader.release());
+    pdfFunctionShader->insertObject("Shading", std::move(pdfShader));
 
     canon->addFunctionShader(pdfFunctionShader.get());
     return pdfFunctionShader.release();
 }
 
 SkPDFImageShader* SkPDFImageShader::Create(
         SkPDFCanon* canon,
         SkScalar dpi,
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
@@ skipping 185 matching lines @@
             if (tileModes[0] == SkShader::kMirror_TileMode) {
                 bottomMatrix.postScale(-1, 1);
                 bottomMatrix.postTranslate(2 * width, 0);
                 drawBitmapMatrix(&canvas, bottom, bottomMatrix);
             }
             patternBBox.fBottom = deviceBounds.height();
         }
     }
 
     // Put the canvas into the pattern stream (fContent).
-    SkAutoTDelete<SkStreamAsset> content(patternDevice->content());
+    auto content = patternDevice->content();
 
     SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->detach());
     imageShader->setData(content.get());
 
-    sk_sp<SkPDFDict> resourceDict(
-            patternDevice->createResourceDict());
+    auto resourceDict = patternDevice->makeResourceDict();
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  resourceDict.get(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     canon->addImageShader(imageShader);
     return imageShader;
 }
 
 bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
@@ skipping 185 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);
 }