detach -> release

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 604 matching lines @@
             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.
     auto alphaGs = create_smask_graphic_state(canon, dpi, state);
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
-            new SkPDFAlphaFunctionShader(autoState->detach());
+            new SkPDFAlphaFunctionShader(autoState->release());
 
     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());
@@ skipping 166 matching lines @@
     pdfShader->insertObject("Domain", sk_ref_sp(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()));
+            new SkPDFFunctionShader(autoState->release()));
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insertObject("Matrix",
                                     SkPDFUtils::MatrixToArray(finalMatrix));
     pdfFunctionShader->insertObject("Shading", std::move(pdfShader));
 
     canon->addFunctionShader(pdfFunctionShader.get());
     return pdfFunctionShader.release();
 }
 
 SkPDFImageShader* SkPDFImageShader::Create(
@@ skipping 191 matching lines @@
                 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->detach());
+    SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->release());
     imageShader->setData(content.get());
 
     auto resourceDict = patternDevice->makeResourceDict();
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  resourceDict.get(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     canon->addImageShader(imageShader);
     return imageShader;
@@ skipping 188 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);
 }