SkPDF: SkPDFStream takes a 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 686 matching lines @@
             state.CreateAlphaToLuminosityState());
     sk_sp<SkPDFObject> luminosityShader(
             get_pdf_shader_by_state(doc, dpi, &alphaToLuminosityState));
 
     std::unique_ptr<SkStreamAsset> 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()));
+            new SkPDFFormXObject(std::move(alphaStream), bbox, resources.get()));
 
     return SkPDFGraphicState::GetSMaskGraphicState(
             alphaMask.get(), false,
             SkPDFGraphicState::kLuminosity_SMaskMode, doc->canon());
 }
 
 SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(
         SkPDFDocument* doc,
         SkScalar dpi,
         std::unique_ptr<SkPDFShader::State>* autoState) {
@@ skipping 14 matching lines @@
     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());
 
     std::unique_ptr<SkStreamAsset> colorStream(
             create_pattern_fill_content(0, bbox));
-    alphaFunctionShader->setData(colorStream.get());
+    alphaFunctionShader->setData(std::move(colorStream));
 
     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.
 // but it returns the inverse of perspective matrix.
 static bool split_perspective(const SkMatrix in, SkMatrix* affine,
@@ skipping 41 matching lines @@
     range->appendInt(1);
     range->appendInt(0);
     range->appendInt(1);
     return range;
 }
 
 static sk_sp<SkPDFStream> make_ps_function(
         std::unique_ptr<SkStreamAsset> psCode,
         SkPDFArray* domain,
         sk_sp<SkPDFObject> range) {
-    auto result = sk_make_sp<SkPDFStream>(psCode.get());
+    auto result = sk_make_sp<SkPDFStream>(std::move(psCode));
     result->insertInt("FunctionType", 4);
     result->insertObject("Domain", sk_ref_sp(domain));
     result->insertObject("Range", std::move(range));
     return result;
 }
 
 // catch cases where the inner just touches the outer circle
 // and make the inner circle just inside the outer one to match raster
 static void FixUpRadius(const SkPoint& p1, SkScalar& r1, const SkPoint& p2, SkScalar& r2) {
     // detect touching circles
@@ skipping 385 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).
-    auto content = patternDevice->content();
-
     SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->release());
-    imageShader->setData(content.get());
+    imageShader->setData(patternDevice->content());
 
     auto resourceDict = patternDevice->makeResourceDict();
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  resourceDict.get(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     doc->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);
 }