SkPDFCanon

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"
 
 #include "SkData.h"
+#include "SkPDFCanon.h"
 #include "SkPDFCatalog.h"
 #include "SkPDFDevice.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
 #include "SkPDFResourceDict.h"
 #include "SkPDFUtils.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkThread.h"
@@ skipping 445 matching lines @@
     function.append("}");
     return function;
 }
 
 static void drawBitmapMatrix(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& matrix) {
     SkAutoCanvasRestore acr(canvas, true);
     canvas->concat(matrix);
     canvas->drawBitmap(bm, 0, 0);
 }
 
-class SkPDFShader::State {
+class SkPDFShaderState {
 public:
     SkShader::GradientType fType;
     SkShader::GradientInfo fInfo;
     SkAutoFree fColorData;    // This provides storage for arrays in fInfo.
     SkMatrix fCanvasTransform;
     SkMatrix fShaderTransform;
     SkIRect fBBox;
 
     SkBitmap fImage;
     uint32_t fPixelGeneration;
     SkShader::TileMode fImageTileModes[2];
 
-    State(const SkShader& shader, const SkMatrix& canvasTransform,
-          const SkIRect& bbox);
+    SkPDFShaderState(const SkShader& shader,
+                     const SkMatrix& canvasTransform,
+                     const SkIRect& bbox);
 
-    bool operator==(const State& b) const;
+    bool operator==(const SkPDFShaderState& b) const;
 
-    SkPDFShader::State* CreateAlphaToLuminosityState() const;
-    SkPDFShader::State* CreateOpaqueState() const;
+    SkPDFShaderState* CreateAlphaToLuminosityState() const;
+    SkPDFShaderState* CreateOpaqueState() const;
 
     bool GradientHasAlpha() const;
 
 private:
-    State(const State& other);
-    State operator=(const State& rhs);
+    SkPDFShaderState(const SkPDFShaderState& other);
+    SkPDFShaderState operator=(const SkPDFShaderState& rhs);
     void AllocateGradientInfoStorage();
 };
 
 class SkPDFFunctionShader : public SkPDFDict, public SkPDFShader {
     SK_DECLARE_INST_COUNT(SkPDFFunctionShader)
 public:
-    explicit SkPDFFunctionShader(SkPDFShader::State* state);
+    explicit SkPDFFunctionShader(SkPDFShaderState* state);
     virtual ~SkPDFFunctionShader() {
         if (isValid()) {
-            RemoveShader(this);
+            SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
+            SkPDFCanon::GetCanon().removeShader(this);
         }
         fResources.unrefAll();
     }
 
     bool isValid() SK_OVERRIDE { return fResources.count() > 0; }
 
+    virtual SkPDFObject* toPDFObject() SK_OVERRIDE {
+        return this;
+    }
+
     void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
                       SkTSet<SkPDFObject*>* newResourceObjects) SK_OVERRIDE {
         GetResourcesHelper(&fResources,
                            knownResourceObjects,
                            newResourceObjects);
     }
 
 private:
     static SkPDFObject* RangeObject();
 
     SkTDArray<SkPDFObject*> fResources;
-    SkAutoTDelete<const SkPDFShader::State> fState;
 
     SkPDFStream* makePSFunction(const SkString& psCode, SkPDFArray* domain);
     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:
-    explicit SkPDFAlphaFunctionShader(SkPDFShader::State* state);
+    explicit SkPDFAlphaFunctionShader(SkPDFShaderState* state);
     virtual ~SkPDFAlphaFunctionShader() {
         if (isValid()) {
-            RemoveShader(this);
+            SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
+            SkPDFCanon::GetCanon().removeShader(this);
         }
     }
 
     bool isValid() SK_OVERRIDE {
         return fColorShader.get() != NULL;
     }
 
+    virtual SkPDFObject* toPDFObject() SK_OVERRIDE {
+        return this;
+    }
+
 private:
-    SkAutoTDelete<const SkPDFShader::State> fState;
-
     SkPDFGraphicState* CreateSMaskGraphicState();
 
     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:
-    explicit SkPDFImageShader(SkPDFShader::State* state);
+    explicit SkPDFImageShader(SkPDFShaderState* state);
     virtual ~SkPDFImageShader() {
         if (isValid()) {
-            RemoveShader(this);
+            SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
+            SkPDFCanon::GetCanon().removeShader(this);
         }
         fResources.unrefAll();
     }
 
     bool isValid() SK_OVERRIDE { return size() > 0; }
 
+    virtual 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;
-    SkAutoTDelete<const SkPDFShader::State> fState;
 };
 
-SkPDFShader::SkPDFShader() {}
+SkPDFShader::SkPDFShader(const SkPDFShaderState* state)
+    : fPDFShaderState(state) {
+}
+
+SkPDFShader::~SkPDFShader() {
+}
+
+bool SkPDFShader::equals(const SkPDFShaderState& state) const {
+    return state == this->pdfShaderState();
+}
+
+const SkPDFShaderState& SkPDFShader::pdfShaderState() const {
+    return *fPDFShaderState;
+}
 
 // static
-SkPDFObject* SkPDFShader::GetPDFShaderByState(State* inState) {
-    SkPDFObject* result;
-
-    SkAutoTDelete<State> shaderState(inState);
+SkPDFObject* SkPDFShader::GetPDFShaderByState(SkPDFShaderState* inState) {
+    SkAutoTDelete<SkPDFShaderState> shaderState(inState);
     if (shaderState.get()->fType == SkShader::kNone_GradientType &&
             shaderState.get()->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;
     }
 
-    ShaderCanonicalEntry entry(NULL, shaderState.get());
-    int index = CanonicalShaders().find(entry);
-    if (index >= 0) {
-        result = CanonicalShaders()[index].fPDFShader;
-        result->ref();
-        return result;
+    SkPDFShader* pdfShader = SkPDFCanon::GetCanon().findShader(*shaderState);
+    if (pdfShader) {
+        return SkRef(pdfShader->toPDFObject());
     }
 
-    bool valid = false;
     // The PDFShader takes ownership of the shaderSate.
-    if (shaderState.get()->fType == SkShader::kNone_GradientType) {
+    if (shaderState->fType == SkShader::kNone_GradientType) {
         SkPDFImageShader* imageShader =
             new SkPDFImageShader(shaderState.detach());
-        valid = imageShader->isValid();
-        result = imageShader;
+        if (imageShader->isValid()) {

[mtklein, 2015/01/20 21:59:52]

Might want to extract this if-else block as add_to_canon(SkPDFShader*) ?

[hal.canary, 2015/01/21 17:07:51]

GREAT idea

+            SkPDFCanon::GetCanon().addShader(imageShader);
+            return imageShader->toPDFObject();
+        } else {
+            SkDELETE(imageShader);
+            return NULL;
+        }
+    } else if (shaderState->GradientHasAlpha()) {
+        SkPDFAlphaFunctionShader* gradientShader =
+                SkNEW_ARGS(SkPDFAlphaFunctionShader, (shaderState.detach()));
+        if (gradientShader->isValid()) {
+            SkPDFCanon::GetCanon().addShader(gradientShader);
+            return gradientShader->toPDFObject();
+        } else {
+            SkDELETE(gradientShader);
+            return NULL;
+        }
     } else {
-        if (shaderState.get()->GradientHasAlpha()) {
-            SkPDFAlphaFunctionShader* gradientShader =
-                SkNEW_ARGS(SkPDFAlphaFunctionShader, (shaderState.detach()));
-            valid = gradientShader->isValid();
-            result = gradientShader;
+        SkPDFFunctionShader* functionShader =
+                SkNEW_ARGS(SkPDFFunctionShader, (shaderState.detach()));
+        if (functionShader->isValid()) {
+            SkPDFCanon::GetCanon().addShader(functionShader);
+            return functionShader->toPDFObject();
         } else {
-            SkPDFFunctionShader* functionShader =
-                SkNEW_ARGS(SkPDFFunctionShader, (shaderState.detach()));
-            valid = functionShader->isValid();
-            result = functionShader;
+            SkDELETE(functionShader);
+            return NULL;
         }
     }
-    if (!valid) {
-        delete result;
-        return NULL;
-    }
-    entry.fPDFShader = result;
-    CanonicalShaders().push(entry);
-    return result;  // return the reference that came from new.
-}
-
-// static
-void SkPDFShader::RemoveShader(SkPDFObject* shader) {
-    SkAutoMutexAcquire lock(CanonicalShadersMutex());
-    ShaderCanonicalEntry entry(shader, NULL);
-    int index = CanonicalShaders().find(entry);
-    SkASSERT(index >= 0);
-    CanonicalShaders().removeShuffle(index);
 }
 
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
                                        const SkMatrix& matrix,
                                        const SkIRect& surfaceBBox) {
-    SkAutoMutexAcquire lock(CanonicalShadersMutex());
+    SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());
     return GetPDFShaderByState(
-            SkNEW_ARGS(State, (shader, matrix, surfaceBBox)));
-}
-
-// static
-SkTDArray<SkPDFShader::ShaderCanonicalEntry>& SkPDFShader::CanonicalShaders() {
-    SkPDFShader::CanonicalShadersMutex().assertHeld();
-    static SkTDArray<ShaderCanonicalEntry> gCanonicalShaders;
-    return gCanonicalShaders;
-}
-
-SK_DECLARE_STATIC_MUTEX(gCanonicalShadersMutex);
-// static
-SkBaseMutex& SkPDFShader::CanonicalShadersMutex() {
-    return gCanonicalShadersMutex;
+            SkNEW_ARGS(SkPDFShaderState, (shader, matrix, surfaceBBox)));
 }
 
 // static
 SkPDFObject* SkPDFFunctionShader::RangeObject() {
-    SkPDFShader::CanonicalShadersMutex().assertHeld();
+    SkPDFCanon::GetShaderMutex().assertHeld();
     static SkPDFArray* range = NULL;
     // This method is only used with CanonicalShadersMutex, so it's safe to
     // populate domain.
     if (range == NULL) {
         range = new SkPDFArray;
         range->reserve(6);
         range->appendInt(0);
         range->appendInt(1);
         range->appendInt(0);
         range->appendInt(1);
@@ skipping 57 matching lines @@
 
     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() {
     SkRect bbox;
-    bbox.set(fState.get()->fBBox);
+    bbox.set(this->pdfShaderState().fBBox);
 
-    SkAutoTUnref<SkPDFObject> luminosityShader(
-            SkPDFShader::GetPDFShaderByState(
-                 fState->CreateAlphaToLuminosityState()));
+    SkAutoTUnref<SkPDFObject> luminosityShader(SkPDFShader::GetPDFShaderByState(
+            this->pdfShaderState().CreateAlphaToLuminosityState()));
 
     SkAutoTUnref<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);
 }
 
-SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
-        : fState(state) {
+SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShaderState* state)
+    : SkPDFShader(state) {
     SkRect bbox;
-    bbox.set(fState.get()->fBBox);
+    bbox.set(this->pdfShaderState().fBBox);
 
     fColorShader.reset(
             SkPDFShader::GetPDFShaderByState(state->CreateOpaqueState()));
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
     SkAutoTUnref<SkPDFGraphicState> alphaGs(CreateSMaskGraphicState());
     fResourceDict.reset(
             get_gradient_resource_dict(fColorShader.get(), alphaGs.get()));
 
@@ skipping 36 matching lines @@
                                zero,         one,        zero,
                                -p0/p2,     -p1/p2,     1/p2);
 
     affine->setAll(sx - p0 * tx / p2,       kx - p1 * tx / p2,      tx / p2,
                    ky - p0 * ty / p2,       sy - p1 * ty / p2,      ty / p2,
                    zero,                    zero,                   one);
 
     return true;
 }
 
-SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
-        : SkPDFDict("Pattern"),
-          fState(state) {
+SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShaderState* state)
+    : SkPDFDict("Pattern"), SkPDFShader(state) {
     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 = &fState.get()->fInfo;
+    const SkShader::GradientInfo* info = &this->pdfShaderState().fInfo;

[mtklein, 2015/01/20 21:59:52]

Why don't we just write "this->pdfShaderState()" as "fState"?

[hal.canary, 2015/01/21 17:07:51]

Done.

     transformPoints[0] = info->fPoint[0];
     transformPoints[1] = info->fPoint[1];
-    switch (fState.get()->fType) {
+    switch (this->pdfShaderState().fType) {
         case SkShader::kLinear_GradientType:
             codeFunction = &linearCode;
             break;
         case SkShader::kRadial_GradientType:
             transformPoints[1] = transformPoints[0];
             transformPoints[1].fX += info->fRadius[0];
             codeFunction = &radialCode;
             break;
         case SkShader::kRadial2_GradientType: {
             // Bail out if the radii are the same.  Empty fResources signals
@@ skipping 24 matching lines @@
             return;
     }
 
     // Move any scaling (assuming a unit gradient) or translation
     // (and rotation for linear gradient), of the final gradient from
     // info->fPoints to the matrix (updating bbox appropriately).  Now
     // the gradient can be drawn on on the unit segment.
     SkMatrix mapperMatrix;
     unitToPointsMatrix(transformPoints, &mapperMatrix);
 
-    SkMatrix finalMatrix = fState.get()->fCanvasTransform;
-    finalMatrix.preConcat(fState.get()->fShaderTransform);
+    SkMatrix finalMatrix = this->pdfShaderState().fCanvasTransform;
+    finalMatrix.preConcat(this->pdfShaderState().fShaderTransform);
     finalMatrix.preConcat(mapperMatrix);
 
     // Preserves as much as posible in the final matrix, and only removes
     // the perspective. The inverse of the perspective is stored in
     // perspectiveInverseOnly matrix and has 3 useful numbers
     // (p0, p1, p2), while everything else is either 0 or 1.
     // In this way the shader will handle it eficiently, with minimal code.
     SkMatrix perspectiveInverseOnly = SkMatrix::I();
     if (finalMatrix.hasPerspective()) {
         if (!split_perspective(finalMatrix,
                                &finalMatrix, &perspectiveInverseOnly)) {
             return;
         }
     }
 
     SkRect bbox;
-    bbox.set(fState.get()->fBBox);
+    bbox.set(this->pdfShaderState().fBBox);
     if (!inverseTransformBBox(finalMatrix, &bbox)) {
         return;
     }
 
     SkAutoTUnref<SkPDFArray> domain(new SkPDFArray);
     domain->reserve(4);
     domain->appendScalar(bbox.fLeft);
     domain->appendScalar(bbox.fRight);
     domain->appendScalar(bbox.fTop);
     domain->appendScalar(bbox.fBottom);
 
     SkString functionCode;
-    // The two point radial gradient further references fState.get()->fInfo
+    // The two point radial gradient further references
+    // this->pdfShaderState().fInfo
     // in translating from x, y coordinates to the t parameter. So, we have
     // to transform the points and radii according to the calculated matrix.
-    if (fState.get()->fType == SkShader::kRadial2_GradientType) {
+    if (this->pdfShaderState().fType == SkShader::kRadial2_GradientType) {
         SkShader::GradientInfo twoPointRadialInfo = *info;
         SkMatrix inverseMapperMatrix;
         if (!mapperMatrix.invert(&inverseMapperMatrix)) {
             return;
         }
         inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
         twoPointRadialInfo.fRadius[0] =
             inverseMapperMatrix.mapRadius(info->fRadius[0]);
         twoPointRadialInfo.fRadius[1] =
             inverseMapperMatrix.mapRadius(info->fRadius[1]);
         functionCode = codeFunction(twoPointRadialInfo, perspectiveInverseOnly);
     } else {
         functionCode = codeFunction(*info, perspectiveInverseOnly);
     }
 
     SkAutoTUnref<SkPDFDict> pdfShader(new SkPDFDict);
     pdfShader->insertInt("ShadingType", 1);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
     pdfShader->insert("Domain", domain.get());
 
     SkPDFStream* function = makePSFunction(functionCode, domain.get());
     pdfShader->insert("Function", new SkPDFObjRef(function))->unref();
     fResources.push(function);  // Pass ownership to resource list.
 
     insertInt("PatternType", 2);
     insert("Matrix", SkPDFUtils::MatrixToArray(finalMatrix))->unref();
     insert("Shading", pdfShader.get());
 }
 
-SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state) : fState(state) {
-    fState.get()->fImage.lockPixels();
+SkPDFImageShader::SkPDFImageShader(SkPDFShaderState* state)
+    : SkPDFShader(state) {
+    this->pdfShaderState().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
     // to handle fake clamping.
-    SkMatrix finalMatrix = fState.get()->fCanvasTransform;
-    finalMatrix.preConcat(fState.get()->fShaderTransform);
+    SkMatrix finalMatrix = this->pdfShaderState().fCanvasTransform;
+    finalMatrix.preConcat(this->pdfShaderState().fShaderTransform);
     SkRect deviceBounds;
-    deviceBounds.set(fState.get()->fBBox);
+    deviceBounds.set(this->pdfShaderState().fBBox);
     if (!inverseTransformBBox(finalMatrix, &deviceBounds)) {
         return;
     }
 
-    const SkBitmap* image = &fState.get()->fImage;
+    const SkBitmap* image = &this->pdfShaderState().fImage;
     SkRect bitmapBounds;
     image->getBounds(&bitmapBounds);
 
     // For tiling modes, the bounds should be extended to include the bitmap,
     // otherwise the bitmap gets clipped out and the shader is empty and awful.
     // For clamp modes, we're only interested in the clip region, whether
     // or not the main bitmap is in it.
     SkShader::TileMode tileModes[2];
-    tileModes[0] = fState.get()->fImageTileModes[0];
-    tileModes[1] = fState.get()->fImageTileModes[1];
+    tileModes[0] = this->pdfShaderState().fImageTileModes[0];
+    tileModes[1] = this->pdfShaderState().fImageTileModes[1];
     if (tileModes[0] != SkShader::kClamp_TileMode ||
             tileModes[1] != SkShader::kClamp_TileMode) {
         deviceBounds.join(bitmapBounds);
     }
 
     SkMatrix unflip;
     unflip.setTranslate(0, SkScalarRoundToScalar(deviceBounds.height()));
     unflip.preScale(SK_Scalar1, -SK_Scalar1);
     SkISize size = SkISize::Make(SkScalarRoundToInt(deviceBounds.width()),
                                  SkScalarRoundToInt(deviceBounds.height()));
@@ skipping 159 matching lines @@
 
     // Put the canvas into the pattern stream (fContent).
     SkAutoTUnref<SkStream> content(pattern.content());
     setData(content.get());
     SkPDFResourceDict* resourceDict = pattern.getResourceDict();
     resourceDict->getReferencedResources(fResources, &fResources, false);
 
     populate_tiling_pattern_dict(this, patternBBox,
                                  pattern.getResourceDict(), finalMatrix);
 
-    fState.get()->fImage.unlockPixels();
+    this->pdfShaderState().fImage.unlockPixels();
 }
 
 SkPDFStream* SkPDFFunctionShader::makePSFunction(const SkString& psCode, SkPDFArray* domain) {
     SkAutoDataUnref funcData(SkData::NewWithCopy(psCode.c_str(), psCode.size()));
     SkPDFStream* result = new SkPDFStream(funcData.get());
     result->insertInt("FunctionType", 4);
     result->insert("Domain", domain);
     result->insert("Range", RangeObject());
     return result;
 }
 
-SkPDFShader::ShaderCanonicalEntry::ShaderCanonicalEntry(SkPDFObject* pdfShader, const State* state)
-    : fPDFShader(pdfShader)
-    , fState(state)
-{}
-
-bool SkPDFShader::ShaderCanonicalEntry::operator==(const ShaderCanonicalEntry& b) const {
-    return fPDFShader == b.fPDFShader ||
-           (fState != NULL && b.fState != NULL && *fState == *b.fState);
-}
-
-bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
+bool SkPDFShaderState::operator==(const SkPDFShaderState& b) const {
     if (fType != b.fType ||
             fCanvasTransform != b.fCanvasTransform ||
             fShaderTransform != b.fShaderTransform ||
             fBBox != b.fBBox) {
         return false;
     }
 
     if (fType == SkShader::kNone_GradientType) {
         if (fPixelGeneration != b.fPixelGeneration ||
                 fPixelGeneration == 0 ||
@@ skipping 33 matching lines @@
                 break;
             case SkShader::kSweep_GradientType:
             case SkShader::kNone_GradientType:
             case SkShader::kColor_GradientType:
                 break;
         }
     }
     return true;
 }
 
-SkPDFShader::State::State(const SkShader& shader,
-                          const SkMatrix& canvasTransform, const SkIRect& bbox)
-        : fCanvasTransform(canvasTransform),
-          fBBox(bbox),
-          fPixelGeneration(0) {
+SkPDFShaderState::SkPDFShaderState(const SkShader& shader,
+                                   const SkMatrix& canvasTransform,
+                                   const SkIRect& bbox)
+    : fCanvasTransform(canvasTransform), fBBox(bbox), fPixelGeneration(0) {
     fInfo.fColorCount = 0;
     fInfo.fColors = NULL;
     fInfo.fColorOffsets = NULL;
     fShaderTransform = shader.getLocalMatrix();
     fImageTileModes[0] = fImageTileModes[1] = SkShader::kClamp_TileMode;
 
     fType = shader.asAGradient(&fInfo);
 
     if (fType == SkShader::kNone_GradientType) {
         SkShader::BitmapType bitmapType;
         SkMatrix matrix;
         bitmapType = shader.asABitmap(&fImage, &matrix, fImageTileModes);
         if (bitmapType != SkShader::kDefault_BitmapType) {
             fImage.reset();
             return;
         }
         SkASSERT(matrix.isIdentity());
         fPixelGeneration = fImage.getGenerationID();
     } else {
         AllocateGradientInfoStorage();
         shader.asAGradient(&fInfo);
     }
 }
 
-SkPDFShader::State::State(const SkPDFShader::State& other)
-  : fType(other.fType),
-    fCanvasTransform(other.fCanvasTransform),
-    fShaderTransform(other.fShaderTransform),
-    fBBox(other.fBBox)
-{
+SkPDFShaderState::SkPDFShaderState(const SkPDFShaderState& other)
+    : fType(other.fType)
+    , fCanvasTransform(other.fCanvasTransform)
+    , fShaderTransform(other.fShaderTransform)
+    , fBBox(other.fBBox) {
     // Only gradients supported for now, since that is all that is used.
     // If needed, image state copy constructor can be added here later.
     SkASSERT(fType != SkShader::kNone_GradientType);
 
     if (fType != SkShader::kNone_GradientType) {
         fInfo = other.fInfo;
 
         AllocateGradientInfoStorage();
         for (int i = 0; i < fInfo.fColorCount; i++) {
             fInfo.fColors[i] = other.fInfo.fColors[i];
             fInfo.fColorOffsets[i] = other.fInfo.fColorOffsets[i];
         }
     }
 }
 
 /**
  * Create a copy of this gradient state with alpha assigned to RGB luminousity.
  * Only valid for gradient states.
  */
-SkPDFShader::State* SkPDFShader::State::CreateAlphaToLuminosityState() const {
+SkPDFShaderState* SkPDFShaderState::CreateAlphaToLuminosityState() const {
     SkASSERT(fType != SkShader::kNone_GradientType);
 
-    SkPDFShader::State* newState = new SkPDFShader::State(*this);
+    SkPDFShaderState* newState = new SkPDFShaderState(*this);
 
     for (int i = 0; i < fInfo.fColorCount; i++) {
         SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
         newState->fInfo.fColors[i] = SkColorSetARGB(255, alpha, alpha, alpha);
     }
 
     return newState;
 }
 
 /**
  * Create a copy of this gradient state with alpha set to fully opaque
  * Only valid for gradient states.
  */
-SkPDFShader::State* SkPDFShader::State::CreateOpaqueState() const {
+SkPDFShaderState* SkPDFShaderState::CreateOpaqueState() const {
     SkASSERT(fType != SkShader::kNone_GradientType);
 
-    SkPDFShader::State* newState = new SkPDFShader::State(*this);
+    SkPDFShaderState* newState = new SkPDFShaderState(*this);
     for (int i = 0; i < fInfo.fColorCount; i++) {
         newState->fInfo.fColors[i] = SkColorSetA(fInfo.fColors[i],
                                                  SK_AlphaOPAQUE);
     }
 
     return newState;
 }
 
 /**
  * Returns true if state is a gradient and the gradient has alpha.
  */
-bool SkPDFShader::State::GradientHasAlpha() const {
+bool SkPDFShaderState::GradientHasAlpha() const {
     if (fType == SkShader::kNone_GradientType) {
         return false;
     }
 
     for (int i = 0; i < fInfo.fColorCount; i++) {
         SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
         if (alpha != SK_AlphaOPAQUE) {
             return true;
         }
     }
     return false;
 }
 
-void SkPDFShader::State::AllocateGradientInfoStorage() {
+void SkPDFShaderState::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);
 }