SkPDF: s/SkAutoTUnref/sk_sp/g

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 569 matching lines @@
  * 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(
         SkPDFCanon* canon, SkScalar dpi, const SkPDFShader::State& state) {
     SkRect bbox;
     bbox.set(state.fBBox);
 
     SkAutoTDelete<SkPDFShader::State> alphaToLuminosityState(
             state.CreateAlphaToLuminosityState());
-    SkAutoTUnref<SkPDFObject> luminosityShader(
+    sk_sp<SkPDFObject> luminosityShader(
             get_pdf_shader_by_state(canon, dpi, &alphaToLuminosityState));
 
     SkAutoTDelete<SkStream> alphaStream(create_pattern_fill_content(-1, bbox));
 
-    SkAutoTUnref<SkPDFDict>
+    sk_sp<SkPDFDict>
         resources(get_gradient_resource_dict(luminosityShader.get(), nullptr));
 
-    SkAutoTUnref<SkPDFFormXObject> alphaMask(
+    sk_sp<SkPDFFormXObject> alphaMask(
             new SkPDFFormXObject(alphaStream.get(), bbox, resources.get()));
 
     return SkPDFGraphicState::GetSMaskGraphicState(
             alphaMask.get(), false,
             SkPDFGraphicState::kLuminosity_SMaskMode);
 }
 
 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());
 
-    SkAutoTUnref<SkPDFObject> colorShader(
+    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.
-    SkAutoTUnref<SkPDFObject> alphaGs(
+    sk_sp<SkPDFObject> alphaGs(
             create_smask_graphic_state(canon, dpi, state));
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
             new SkPDFAlphaFunctionShader(autoState->detach());
 
-    SkAutoTUnref<SkPDFDict> resourceDict(
+    sk_sp<SkPDFDict> 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 123 matching lines @@
             return nullptr;
         }
     }
 
     SkRect bbox;
     bbox.set(state.fBBox);
     if (!inverse_transform_bbox(finalMatrix, &bbox)) {
         return nullptr;
     }
 
-    SkAutoTUnref<SkPDFArray> domain(new SkPDFArray);
+    sk_sp<SkPDFArray> domain(new SkPDFArray);
     domain->reserve(4);
     domain->appendScalar(bbox.fLeft);
     domain->appendScalar(bbox.fRight);
     domain->appendScalar(bbox.fTop);
     domain->appendScalar(bbox.fBottom);
 
     SkString functionCode;
     // The two point radial gradient further references
     // state.fInfo
     // in translating from x, y coordinates to the t parameter. So, we have
     // to transform the points and radii according to the calculated matrix.
     if (state.fType == SkShader::kConical_GradientType) {
         SkShader::GradientInfo twoPointRadialInfo = *info;
         SkMatrix inverseMapperMatrix;
         if (!mapperMatrix.invert(&inverseMapperMatrix)) {
             return nullptr;
         }
         inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
         twoPointRadialInfo.fRadius[0] =
             inverseMapperMatrix.mapRadius(info->fRadius[0]);
         twoPointRadialInfo.fRadius[1] =
             inverseMapperMatrix.mapRadius(info->fRadius[1]);
         functionCode = codeFunction(twoPointRadialInfo, perspectiveInverseOnly);
     } else {
         functionCode = codeFunction(*info, perspectiveInverseOnly);
     }
 
-    SkAutoTUnref<SkPDFDict> pdfShader(new SkPDFDict);
+    sk_sp<SkPDFDict> pdfShader(new SkPDFDict);
     pdfShader->insertInt("ShadingType", 1);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
     pdfShader->insertObject("Domain", SkRef(domain.get()));
 
-    SkAutoTUnref<SkPDFStream> function(
+    sk_sp<SkPDFStream> function(
             make_ps_function(functionCode, domain.get()));
     pdfShader->insertObjRef("Function", function.release());
 
-    SkAutoTUnref<SkPDFFunctionShader> pdfFunctionShader(new SkPDFFunctionShader(autoState->detach()));
+    sk_sp<SkPDFFunctionShader> pdfFunctionShader(new SkPDFFunctionShader(autoState->detach()));
 
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insertObject("Matrix",
                                     SkPDFUtils::MatrixToArray(finalMatrix));
     pdfFunctionShader->insertObject("Shading", pdfShader.release());
 
     canon->addFunctionShader(pdfFunctionShader.get());
     return pdfFunctionShader.release();
 }
 
@@ skipping 30 matching lines @@
     SkShader::TileMode tileModes[2];
     tileModes[0] = state.fImageTileModes[0];
     tileModes[1] = state.fImageTileModes[1];
     if (tileModes[0] != SkShader::kClamp_TileMode ||
             tileModes[1] != SkShader::kClamp_TileMode) {
         deviceBounds.join(bitmapBounds);
     }
 
     SkISize size = SkISize::Make(SkScalarRoundToInt(deviceBounds.width()),
                                  SkScalarRoundToInt(deviceBounds.height()));
-    SkAutoTUnref<SkPDFDevice> patternDevice(
+    sk_sp<SkPDFDevice> patternDevice(
             SkPDFDevice::CreateUnflipped(size, dpi, canon));
     SkCanvas canvas(patternDevice.get());
 
     SkRect patternBBox;
     image->getBounds(&patternBBox);
 
     // Translate the canvas so that the bitmap origin is at (0, 0).
     canvas.translate(-deviceBounds.left(), -deviceBounds.top());
     patternBBox.offset(-deviceBounds.left(), -deviceBounds.top());
     // Undo the translation in the final matrix
@@ skipping 144 matching lines @@
             patternBBox.fBottom = deviceBounds.height();
         }
     }
 
     // Put the canvas into the pattern stream (fContent).
     SkAutoTDelete<SkStreamAsset> content(patternDevice->content());
 
     SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->detach());
     imageShader->setData(content.get());
 
-    SkAutoTUnref<SkPDFDict> resourceDict(
+    sk_sp<SkPDFDict> resourceDict(
             patternDevice->createResourceDict());
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  resourceDict.get(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     canon->addImageShader(imageShader);
     return imageShader;
 }
 
@@ skipping 186 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);
 }