SkPDF: PDFShader code modernized.

src/pdf/SkPDFCanon.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImage.h"
 #include "SkPDFBitmap.h"
 #include "SkPDFCanon.h"
 #include "SkPDFFont.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void SkPDFCanon::reset() {
     for (int i = 0; i < fFontRecords.count(); ++i) {
         fFontRecords[i].fFont->unref();
     }
     fFontRecords.reset();
-    fFunctionShaderRecords.unrefAll();
+
     fFunctionShaderRecords.reset();
-    fAlphaShaderRecords.unrefAll();
     fAlphaShaderRecords.reset();
-    fImageShaderRecords.unrefAll();
     fImageShaderRecords.reset();
+
     fGraphicStateRecords.foreach ([](WrapGS w) { w.fPtr->unref(); });

[tomhudson, 2016/08/02 20:59:12]

Nit: TODO(halcanary) replace with sk_sp<> so we don't need the explicit
teardown?

[hal.canary, 2016/08/02 21:25:01]

Done.

     fGraphicStateRecords.reset();
 
     fPDFBitmapMap.foreach([](SkBitmapKey, SkPDFObject** p) { (*p)->unref(); });
     fPDFBitmapMap.reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T> T* assert_ptr(T* p) { SkASSERT(p); return p; }
-
-// requires `bool T::equals(const U&) const`
-template <typename T, typename U>
-T* find_item(const SkTDArray<T*>& ptrArray, const U& object) {
-    for (int i = 0; i < ptrArray.count(); ++i) {
-        if (ptrArray[i]->equals(object)) {
-            return ptrArray[i];
-        }
-    }
-    return nullptr;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 SkPDFFont* SkPDFCanon::findFont(uint32_t fontID,
                                 uint16_t glyphID,
                                 SkPDFFont** relatedFontPtr) const {
     SkASSERT(relatedFontPtr);
 
     SkPDFFont* relatedFont = nullptr;
     for (int i = 0; i < fFontRecords.count(); ++i) {
         SkPDFFont::Match match = SkPDFFont::IsMatch(
                 fFontRecords[i].fFont, fFontRecords[i].fFontID,
                 fFontRecords[i].fGlyphID, fontID, glyphID);
         if (SkPDFFont::kExact_Match == match) {
             return fFontRecords[i].fFont;
         } else if (!relatedFont && SkPDFFont::kRelated_Match == match) {
             relatedFont = fFontRecords[i].fFont;
         }
     }
     *relatedFontPtr = relatedFont;  // May still be nullptr.
     return nullptr;
 }
 
 void SkPDFCanon::addFont(SkPDFFont* font, uint32_t fontID, uint16_t fGlyphID) {
     SkPDFCanon::FontRec* rec = fFontRecords.push();
     rec->fFont = SkRef(font);
     rec->fFontID = fontID;
     rec->fGlyphID = fGlyphID;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFFunctionShader* SkPDFCanon::findFunctionShader(
+template <typename T>
+sk_sp<SkPDFObject> find_shader(const SkTArray<T>& records,
+                               const SkPDFShader::State& state) {
+    for (const T& record : records) {
+        if (record.fShaderState == state) {
+            return record.fShaderObject;
+        }
+    }
+    return nullptr;
+}
+
+sk_sp<SkPDFObject> SkPDFCanon::findFunctionShader(
         const SkPDFShader::State& state) const {
-    return find_item(fFunctionShaderRecords, state);
+    return find_shader(fFunctionShaderRecords, state);
 }
-void SkPDFCanon::addFunctionShader(SkPDFFunctionShader* pdfShader) {
-    fFunctionShaderRecords.push(SkRef(pdfShader));
+void SkPDFCanon::addFunctionShader(sk_sp<SkPDFObject> pdfShader,
+                                   SkPDFShader::State state) {
+    fFunctionShaderRecords.emplace_back(std::move(state), std::move(pdfShader));
+}
+
+sk_sp<SkPDFObject> SkPDFCanon::findAlphaShader(
+        const SkPDFShader::State& state) const {
+    return find_shader(fAlphaShaderRecords, state);
+}
+void SkPDFCanon::addAlphaShader(sk_sp<SkPDFObject> pdfShader,
+                                SkPDFShader::State state) {
+    fAlphaShaderRecords.emplace_back(std::move(state), std::move(pdfShader));
+}
+
+sk_sp<SkPDFObject> SkPDFCanon::findImageShader(
+        const SkPDFShader::State& state) const {
+    return find_shader(fImageShaderRecords, state);
+}
+
+void SkPDFCanon::addImageShader(sk_sp<SkPDFObject> pdfShader,
+                                SkPDFShader::State state) {
+    fImageShaderRecords.emplace_back(std::move(state), std::move(pdfShader));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-
-SkPDFAlphaFunctionShader* SkPDFCanon::findAlphaShader(
-        const SkPDFShader::State& state) const {
-    return find_item(fAlphaShaderRecords, state);
-}
-void SkPDFCanon::addAlphaShader(SkPDFAlphaFunctionShader* pdfShader) {
-    fAlphaShaderRecords.push(SkRef(pdfShader));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-SkPDFImageShader* SkPDFCanon::findImageShader(
-        const SkPDFShader::State& state) const {
-    return find_item(fImageShaderRecords, state);
-}
-
-void SkPDFCanon::addImageShader(SkPDFImageShader* pdfShader) {
-    fImageShaderRecords.push(SkRef(pdfShader));
-}
-
-////////////////////////////////////////////////////////////////////////////////
 
 const SkPDFGraphicState* SkPDFCanon::findGraphicState(
         const SkPDFGraphicState& key) const {
     const WrapGS* ptr = fGraphicStateRecords.find(WrapGS(&key));
     return ptr ? ptr->fPtr : nullptr;
 }
 
 void SkPDFCanon::addGraphicState(const SkPDFGraphicState* state) {
     SkASSERT(state);
     WrapGS w(SkRef(state));
@@ skipping 28 matching lines @@
     fNoSmaskGraphicState = SkPDFGraphicState::MakeNoSmaskGraphicState();
     return fNoSmaskGraphicState;
 }
 sk_sp<SkPDFArray> SkPDFCanon::makeRangeObject() {
     if (fRangeObject) {
         return fRangeObject;
     }
     fRangeObject = SkPDFShader::MakeRangeObject();
     return fRangeObject;
 }