SkPDF: PDFStream has-a not is-a PDFDict

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 725 matching lines @@
     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(std::move(colorStream));
 
-    populate_tiling_pattern_dict(alphaFunctionShader, bbox, resourceDict.get(),
-                                 SkMatrix::I());
+    populate_tiling_pattern_dict(
+            alphaFunctionShader->dict(), 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,
                               SkMatrix* perspectiveInverse) {
     const SkScalar p2 = in[SkMatrix::kMPersp2];
 
@@ skipping 39 matching lines @@
     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>(std::move(psCode));
-    result->insertInt("FunctionType", 4);
-    result->insertObject("Domain", sk_ref_sp(domain));
-    result->insertObject("Range", std::move(range));
+    result->dict()->insertInt("FunctionType", 4);
+    result->dict()->insertObject("Domain", sk_ref_sp(domain));
+    result->dict()->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
     SkScalar distance = SkPoint::Distance(p1, p2);
     SkScalar subtractRadii = fabs(r1 - r2);
     if (fabs(distance - subtractRadii) < 0.002f) {
@@ skipping 386 matching lines @@
             }
             patternBBox.fBottom = deviceBounds.height();
         }
     }
 
     // Put the canvas into the pattern stream (fContent).
     SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->release());
     imageShader->setData(patternDevice->content());
 
     auto resourceDict = patternDevice->makeResourceDict();
-    populate_tiling_pattern_dict(imageShader, patternBBox,
+    populate_tiling_pattern_dict(imageShader->dict(), patternBBox,
                                  resourceDict.get(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     doc->canon()->addImageShader(imageShader);
     return imageShader;
 }
 
 bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
     if (fType != b.fType ||
@@ skipping 183 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);
 }