SkPDF s/SkAutoTDelete/std::unique_ptr/

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 470 matching lines @@
     return state == *fShaderState;
 }
 
 SkPDFImageShader::~SkPDFImageShader() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static SkPDFObject* get_pdf_shader_by_state(
         SkPDFDocument* doc,
         SkScalar dpi,
-        SkAutoTDelete<SkPDFShader::State>* autoState) {
+        std::unique_ptr<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
     SkPDFCanon* canon = doc->canon();
     if (state.fType == SkShader::kNone_GradientType && state.fImage.isNull()) {
         // TODO(vandebo) This drops SKComposeShader on the floor.  We could
         // handle compose shader by pulling things up to a layer, drawing with
         // the first shader, applying the xfer mode and drawing again with the
         // second shader, then applying the layer to the original drawing.
         return nullptr;
     } else if (state.fType == SkShader::kNone_GradientType) {
         SkPDFObject* shader = canon->findImageShader(state);
@@ skipping 10 matching lines @@
     }
 }
 
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(SkPDFDocument* doc,
                                        SkScalar dpi,
                                        SkShader* shader,
                                        const SkMatrix& matrix,
                                        const SkIRect& surfaceBBox,
                                        SkScalar rasterScale) {
-    SkAutoTDelete<SkPDFShader::State> state(new State(shader, matrix, surfaceBBox, rasterScale));
+    std::unique_ptr<SkPDFShader::State> state(new State(shader, matrix, surfaceBBox, rasterScale));
     return get_pdf_shader_by_state(doc, dpi, &state);
 }
 
 static sk_sp<SkPDFDict> get_gradient_resource_dict(
         SkPDFObject* functionShader,
         SkPDFObject* gState) {
     SkTDArray<SkPDFObject*> patterns;
     if (functionShader) {
         patterns.push(functionShader);
     }
@@ skipping 45 matching lines @@
 
 /**
  * Creates a ExtGState with the SMask set to the luminosityShader in
  * luminosity mode. The shader pattern extends to the bbox.
  */
 static sk_sp<SkPDFObject> create_smask_graphic_state(
         SkPDFDocument* doc, SkScalar dpi, const SkPDFShader::State& state) {
     SkRect bbox;
     bbox.set(state.fBBox);
 
-    SkAutoTDelete<SkPDFShader::State> alphaToLuminosityState(
+    std::unique_ptr<SkPDFShader::State> alphaToLuminosityState(
             state.CreateAlphaToLuminosityState());
     sk_sp<SkPDFObject> luminosityShader(
             get_pdf_shader_by_state(doc, dpi, &alphaToLuminosityState));
 
-    SkAutoTDelete<SkStream> alphaStream(create_pattern_fill_content(-1, bbox));
+    std::unique_ptr<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, doc->canon());
 }
 
 SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(
         SkPDFDocument* doc,
         SkScalar dpi,
-        SkAutoTDelete<SkPDFShader::State>* autoState) {
+        std::unique_ptr<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
     SkRect bbox;
     bbox.set(state.fBBox);
 
-    SkAutoTDelete<SkPDFShader::State> opaqueState(state.CreateOpaqueState());
+    std::unique_ptr<SkPDFShader::State> opaqueState(state.CreateOpaqueState());
 
     sk_sp<SkPDFObject> colorShader(
             get_pdf_shader_by_state(doc, dpi, &opaqueState));
     if (!colorShader) {
         return nullptr;
     }
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
     auto alphaGs = create_smask_graphic_state(doc, dpi, state);
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
             new SkPDFAlphaFunctionShader(autoState->release());
 
     auto resourceDict =
             get_gradient_resource_dict(colorShader.get(), alphaGs.get());
 
-    SkAutoTDelete<SkStream> colorStream(
+    std::unique_ptr<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     alphaFunctionShader->setData(colorStream.get());
 
     populate_tiling_pattern_dict(alphaFunctionShader, bbox, resourceDict.get(),
                                  SkMatrix::I());
     doc->canon()->addAlphaShader(alphaFunctionShader);
     return alphaFunctionShader;
 }
 
 // Finds affine and persp such that in = affine * persp.
@@ skipping 51 matching lines @@
         SkPDFArray* domain,
         sk_sp<SkPDFObject> range) {
     auto result = sk_make_sp<SkPDFStream>(psCode.get());
     result->insertInt("FunctionType", 4);
     result->insertObject("Domain", sk_ref_sp(domain));
     result->insertObject("Range", std::move(range));
     return result;
 }
 
 SkPDFFunctionShader* SkPDFFunctionShader::Create(
-        SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {
+        SkPDFCanon* canon, std::unique_ptr<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
     void (*codeFunction)(const SkShader::GradientInfo& info,
                          const SkMatrix& perspectiveRemover,
                          SkDynamicMemoryWStream* function) = nullptr;
     SkPoint transformPoints[2];
 
     // Depending on the type of the gradient, we want to transform the
     // coordinate space in different ways.
     const SkShader::GradientInfo* info = &state.fInfo;
@@ skipping 104 matching lines @@
                                     SkPDFUtils::MatrixToArray(finalMatrix));
     pdfFunctionShader->insertObject("Shading", std::move(pdfShader));
 
     canon->addFunctionShader(pdfFunctionShader.get());
     return pdfFunctionShader.release();
 }
 
 SkPDFImageShader* SkPDFImageShader::Create(
         SkPDFDocument* doc,
         SkScalar dpi,
-        SkAutoTDelete<SkPDFShader::State>* autoState) {
+        std::unique_ptr<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
     state.fImage.lockPixels();
 
     // The image shader pattern cell will be drawn into a separate device
     // in pattern cell space (no scaling on the bitmap, though there may be
     // translations so that all content is in the device, coordinates > 0).
 
     // Map clip bounds to shader space to ensure the device is large enough
     // to handle fake clamping.
@@ skipping 387 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);
 }