More changes to SkPDFShader to eliminate multiple inheritance!

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 487 matching lines @@
     SkPDFShader::State* CreateOpaqueState() const;
 
     bool GradientHasAlpha() const;
 
 private:
     State(const State& other);
     State operator=(const State& rhs);
     void AllocateGradientInfoStorage();
 };
 
-static void remove_from_canon(SkPDFShader* shader) {
-    SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
-    SkPDFCanon::GetCanon().removeShader(shader);
+////////////////////////////////////////////////////////////////////////////////
+
+SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
+    : SkPDFDict("Pattern"), fShaderState(state) {}
+
+void SkPDFFunctionShader::getResources(const SkTSet<SkPDFObject*>& known,
+                                       SkTSet<SkPDFObject*>* newr) {
+    GetResourcesHelper(&fResources, known, newr);
 }
 
-class SkPDFFunctionShader : public SkPDFDict, public SkPDFShader {
-    SK_DECLARE_INST_COUNT(SkPDFFunctionShader)
-public:
-    static SkPDFObject* Create(SkAutoTDelete<SkPDFShader::State>*);
-
-    virtual ~SkPDFFunctionShader() {
-        remove_from_canon(this);
-        fResources.unrefAll();
-    }
-
-    SkPDFObject* toPDFObject() SK_OVERRIDE { return this; }
-
-    void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
-                      SkTSet<SkPDFObject*>* newResourceObjects) SK_OVERRIDE {
-        GetResourcesHelper(&fResources,
-                           knownResourceObjects,
-                           newResourceObjects);
-    }
-
-private:
-    SkTDArray<SkPDFObject*> fResources;
-    explicit SkPDFFunctionShader(SkPDFShader::State* state)
-        : SkPDFDict("Pattern"), SkPDFShader(state) {}
-    typedef SkPDFDict INHERITED;
-};
-
-/**
- * A shader for PDF gradients. This encapsulates the function shader
- * inside a tiling pattern while providing a common pattern interface.
- * The encapsulation allows the use of a SMask for transparency gradients.
- */
-class SkPDFAlphaFunctionShader : public SkPDFStream, public SkPDFShader {
-public:
-    static SkPDFObject* Create(SkAutoTDelete<SkPDFShader::State>*);
-
-    virtual ~SkPDFAlphaFunctionShader() { remove_from_canon(this); }
-
-    SkPDFObject* toPDFObject() SK_OVERRIDE { return this; }
-
-private:
-    explicit SkPDFAlphaFunctionShader(SkPDFShader::State* state);
-
-    static SkPDFGraphicState* CreateSMaskGraphicState(
-            const SkPDFShader::State&);
-
-    void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
-                      SkTSet<SkPDFObject*>* newResourceObjects) SK_OVERRIDE {
-        fResourceDict->getReferencedResources(knownResourceObjects,
-                                              newResourceObjects,
-                                              true);
-    }
-
-    SkAutoTUnref<SkPDFObject> fColorShader;
-    SkAutoTUnref<SkPDFResourceDict> fResourceDict;
-};
-
-class SkPDFImageShader : public SkPDFStream, public SkPDFShader {
-public:
-    static SkPDFObject* Create(SkAutoTDelete<SkPDFShader::State>*);
-
-    virtual ~SkPDFImageShader() {
-        remove_from_canon(this);
-        fResources.unrefAll();
-    }
-
-    SkPDFObject* toPDFObject() SK_OVERRIDE { return this; }
-
-    void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
-                      SkTSet<SkPDFObject*>* newResourceObjects) SK_OVERRIDE {
-        GetResourcesHelper(&fResources.toArray(),
-                           knownResourceObjects,
-                           newResourceObjects);
-    }
-
-private:
-    SkTSet<SkPDFObject*> fResources;
-    explicit SkPDFImageShader(SkPDFShader::State* state) : SkPDFShader(state) {}
-};
-
-SkPDFShader::SkPDFShader(SkPDFShader::State* s) : fShaderState(s) {}
-
-SkPDFShader::~SkPDFShader() {}
-
-bool SkPDFShader::equals(const SkPDFShader::State& state) const {
-    return state == *fShaderState.get();
+SkPDFFunctionShader::~SkPDFFunctionShader() {
+    SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
+    SkPDFCanon::GetCanon().removeFunctionShader(this);
+    lock.release();
+    fResources.unrefAll();
 }
 
-// static
-SkPDFObject* SkPDFShader::GetPDFShaderByState(
+bool SkPDFFunctionShader::equals(const SkPDFShader::State& state) const {
+    return state == *fShaderState;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
+    : fShaderState(state) {}
+
+bool SkPDFAlphaFunctionShader::equals(const SkPDFShader::State& state) const {
+    return state == *fShaderState;
+}
+
+SkPDFAlphaFunctionShader::~SkPDFAlphaFunctionShader() {
+    SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
+    SkPDFCanon::GetCanon().removeAlphaShader(this);
+}
+
+void SkPDFAlphaFunctionShader::getResources(const SkTSet<SkPDFObject*>& known,
+                                            SkTSet<SkPDFObject*>* newr) {
+    fResourceDict->getReferencedResources(known, newr, true);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state)
+    : fShaderState(state) {}
+
+bool SkPDFImageShader::equals(const SkPDFShader::State& state) const {
+    return state == *fShaderState;
+}
+
+SkPDFImageShader::~SkPDFImageShader() {
+    SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
+    SkPDFCanon::GetCanon().removeImageShader(this);
+    lock.release();
+    fResources.unrefAll();
+}
+
+void SkPDFImageShader::getResources(const SkTSet<SkPDFObject*>& known,
+                                    SkTSet<SkPDFObject*>* newr) {
+    GetResourcesHelper(&fResources.toArray(), known, newr);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+static SkPDFObject* get_pdf_shader_by_state(
         SkAutoTDelete<SkPDFShader::State>* autoState) {
-    const State& state = **autoState;
+    const SkPDFShader::State& state = **autoState;
     if (state.fType == SkShader::kNone_GradientType && state.fImage.isNull()) {
         // TODO(vandebo) This drops SKComposeShader on the floor.  We could
         // handle compose shader by pulling things up to a layer, drawing with
         // the first shader, applying the xfer mode and drawing again with the
         // second shader, then applying the layer to the original drawing.
         return NULL;
-    }
-
-    SkPDFShader* pdfShader = SkPDFCanon::GetCanon().findShader(state);
-    if (pdfShader) {
-        return SkRef(pdfShader->toPDFObject());
-    }
-
-    // The PDFShader takes ownership of the shaderSate.
-    if (state.fType == SkShader::kNone_GradientType) {
-        return SkPDFImageShader::Create(autoState);
+    } else if (state.fType == SkShader::kNone_GradientType) {
+        SkPDFObject* shader = SkPDFCanon::GetCanon().findImageShader(state);
+        return shader ? SkRef(shader) : SkPDFImageShader::Create(autoState);
     } else if (state.GradientHasAlpha()) {
-        return SkPDFAlphaFunctionShader::Create(autoState);
+        SkPDFObject* shader = SkPDFCanon::GetCanon().findAlphaShader(state);
+        return shader ? SkRef(shader)
+                      : SkPDFAlphaFunctionShader::Create(autoState);
     } else {
-        return SkPDFFunctionShader::Create(autoState);
+        SkPDFObject* shader = SkPDFCanon::GetCanon().findFunctionShader(state);
+        return shader ? SkRef(shader) : SkPDFFunctionShader::Create(autoState);
     }
 }
 
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
                                        const SkMatrix& matrix,
                                        const SkIRect& surfaceBBox,
                                        SkScalar rasterScale) {
+    // There is only one mutex becasue we don't know which one we'll need.
     SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
     SkAutoTDelete<SkPDFShader::State> state(
             SkNEW_ARGS(State, (shader, matrix, surfaceBBox, rasterScale)));
-    return GetPDFShaderByState(&state);
+    return get_pdf_shader_by_state(&state);
 }
 
 static SkPDFResourceDict* get_gradient_resource_dict(
         SkPDFObject* functionShader,
         SkPDFObject* gState) {
     SkPDFResourceDict* dict = new SkPDFResourceDict();
 
     if (functionShader != NULL) {
         dict->insertResourceAsReference(
                 SkPDFResourceDict::kPattern_ResourceType, 0, functionShader);
@@ skipping 41 matching lines @@
     SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kEvenOdd_FillType,
                           &content);
 
     return content.detachAsStream();
 }
 
 /**
  * Creates a ExtGState with the SMask set to the luminosityShader in
  * luminosity mode. The shader pattern extends to the bbox.
  */
-SkPDFGraphicState* SkPDFAlphaFunctionShader::CreateSMaskGraphicState(
+static SkPDFGraphicState* createsmask_graphic_state(
         const SkPDFShader::State& state) {
     SkRect bbox;
     bbox.set(state.fBBox);
 
     SkAutoTDelete<SkPDFShader::State> alphaToLuminosityState(
             state.CreateAlphaToLuminosityState());
     SkAutoTUnref<SkPDFObject> luminosityShader(
-            SkPDFShader::GetPDFShaderByState(&alphaToLuminosityState));
+            get_pdf_shader_by_state(&alphaToLuminosityState));
 
     SkAutoTDelete<SkStream> alphaStream(create_pattern_fill_content(-1, bbox));
 
     SkAutoTUnref<SkPDFResourceDict>
         resources(get_gradient_resource_dict(luminosityShader, NULL));
 
     SkAutoTUnref<SkPDFFormXObject> alphaMask(
             new SkPDFFormXObject(alphaStream.get(), bbox, resources.get()));
 
     return SkPDFGraphicState::GetSMaskGraphicState(
             alphaMask.get(), false,
             SkPDFGraphicState::kLuminosity_SMaskMode);
 }
 
-SkPDFObject* SkPDFAlphaFunctionShader::Create(
+SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
     SkRect bbox;
     bbox.set(state.fBBox);
 
     SkAutoTDelete<SkPDFShader::State> opaqueState(state.CreateOpaqueState());
 
-    SkPDFObject* colorShader = SkPDFShader::GetPDFShaderByState(&opaqueState);
+    SkPDFObject* colorShader = get_pdf_shader_by_state(&opaqueState);
     if (!colorShader) {
         return NULL;
     }
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
-    SkAutoTUnref<SkPDFGraphicState> alphaGs(
-            SkPDFAlphaFunctionShader::CreateSMaskGraphicState(state));
+    SkAutoTUnref<SkPDFGraphicState> alphaGs(createsmask_graphic_state(state));

[mtklein, 2015/01/23 14:16:11]

Let's add an _ between create and smask?

 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
             SkNEW_ARGS(SkPDFAlphaFunctionShader, (autoState->detach()));
 
     alphaFunctionShader->fColorShader.reset(colorShader);
 
     alphaFunctionShader->fResourceDict.reset(get_gradient_resource_dict(
             alphaFunctionShader->fColorShader.get(), alphaGs.get()));
 
     SkAutoTDelete<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     alphaFunctionShader->setData(colorStream.get());
 
     populate_tiling_pattern_dict(alphaFunctionShader, bbox,
                                  alphaFunctionShader->fResourceDict.get(),
                                  SkMatrix::I());
-    SkPDFCanon::GetCanon().addShader(alphaFunctionShader);
+    SkPDFCanon::GetCanon().addAlphaShader(alphaFunctionShader);
     return alphaFunctionShader;
 }
 
-SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
-    : SkPDFShader(state) {}
-
 // 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];
 
     if (SkScalarNearlyZero(p2)) {
         return false;
     }
 
@@ skipping 48 matching lines @@
                                      SkPDFArray* domain) {
     SkAutoDataUnref funcData(
             SkData::NewWithCopy(psCode.c_str(), psCode.size()));
     SkPDFStream* result = SkNEW_ARGS(SkPDFStream, (funcData.get()));
     result->insertInt("FunctionType", 4);
     result->insert("Domain", domain);
     result->insert("Range", rangeObject.get());
     return result;
 }
 
-SkPDFObject* SkPDFFunctionShader::Create(
+SkPDFFunctionShader* SkPDFFunctionShader::Create(
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
     SkString (*codeFunction)(const SkShader::GradientInfo& info,
                              const SkMatrix& perspectiveRemover) = NULL;
     SkPoint transformPoints[2];
 
     // Depending on the type of the gradient, we want to transform the
     // coordinate space in different ways.
     const SkShader::GradientInfo* info = &state.fInfo;
@@ skipping 108 matching lines @@
     SkPDFFunctionShader* pdfFunctionShader =
             SkNEW_ARGS(SkPDFFunctionShader, (autoState->detach()));
 
     pdfFunctionShader->fResources.push(function);
     // Pass ownership to resource list.
 
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insert("Matrix", matrixArray.get());
     pdfFunctionShader->insert("Shading", pdfShader.get());
 
-    SkPDFCanon::GetCanon().addShader(pdfFunctionShader);
+    SkPDFCanon::GetCanon().addFunctionShader(pdfFunctionShader);
     return pdfFunctionShader;
 }
 
-SkPDFObject* SkPDFImageShader::Create(
+SkPDFImageShader* SkPDFImageShader::Create(
         SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
     state.fImage.lockPixels();
 
     // The image shader pattern cell will be drawn into a separate device
     // in pattern cell space (no scaling on the bitmap, though there may be
     // translations so that all content is in the device, coordinates > 0).
 
     // Map clip bounds to shader space to ensure the device is large enough
@@ skipping 196 matching lines @@
 
     SkPDFResourceDict* resourceDict = pattern.getResourceDict();
     resourceDict->getReferencedResources(imageShader->fResources,
                                          &imageShader->fResources, false);
 
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  pattern.getResourceDict(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
-    SkPDFCanon::GetCanon().addShader(imageShader);
+    SkPDFCanon::GetCanon().addImageShader(imageShader);
     return imageShader;
 }
 
 bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
     if (fType != b.fType ||
             fCanvasTransform != b.fCanvasTransform ||
             fShaderTransform != b.fShaderTransform ||
             fBBox != b.fBBox) {
         return false;
     }
@@ skipping 173 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);
 }