PDF: Now threadsafe!

src/pdf/SkPDFGraphicState.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 "SkData.h"
 #include "SkLazyPtr.h"
 #include "SkPDFCanon.h"
@@ skipping 95 matching lines @@
     SkASSERT(bXfermodeString != NULL);
 
     return strcmp(aXfermodeString, bXfermodeString) == 0;
 }
 
 bool SkPDFGraphicState::equals(const SkPaint& paint) const {
     return equivalent(paint, fPaint);
 }
 
 SkPDFGraphicState::~SkPDFGraphicState() {
-    SkAutoMutexAcquire lock(SkPDFCanon::GetPaintMutex());
-    if (!fSMask) {
-        SkPDFCanon::GetCanon().removeGraphicState(this);
+    if (fCanon) {
+        fCanon->removeGraphicState(this);
     }
 }
 
 void SkPDFGraphicState::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     populateDict();
     SkPDFDict::emitObject(stream, catalog);
 }
 
 // static
 SkPDFGraphicState* SkPDFGraphicState::GetGraphicStateForPaint(
-        const SkPaint& paint) {
-    SkAutoMutexAcquire lock(SkPDFCanon::GetPaintMutex());
-    SkPDFGraphicState* pdfGraphicState =
-            SkPDFCanon::GetCanon().findGraphicState(paint);
+        SkPDFCanon* canon, const SkPaint& paint) {
+    SkASSERT(canon);
+    SkPDFGraphicState* pdfGraphicState = canon->findGraphicState(paint);
     if (pdfGraphicState) {
         return SkRef(pdfGraphicState);
     }
-    pdfGraphicState = new SkPDFGraphicState(paint);
-    SkPDFCanon::GetCanon().addGraphicState(pdfGraphicState);
+    pdfGraphicState = new SkPDFGraphicState(canon, paint);
+    canon->addGraphicState(pdfGraphicState);
     return pdfGraphicState;
 }
 
 namespace {
 SkPDFObject* create_invert_function() {
     // Acrobat crashes if we use a type 0 function, kpdf crashes if we use
     // a type 2 function, so we use a type 4 function.
     SkAutoTUnref<SkPDFArray> domainAndRange(new SkPDFArray);
     domainAndRange->reserve(2);
     domainAndRange->appendInt(0);
@@ skipping 26 matching lines @@
     SkAutoTUnref<SkPDFDict> sMaskDict(new SkPDFDict("Mask"));
     if (sMaskMode == kAlpha_SMaskMode) {
         sMaskDict->insertName("S", "Alpha");
     } else if (sMaskMode == kLuminosity_SMaskMode) {
         sMaskDict->insertName("S", "Luminosity");
     }
     sMaskDict->insert("G", new SkPDFObjRef(sMask))->unref();
 
     SkPDFGraphicState* result = new SkPDFGraphicState;
     result->fPopulated = true;
-    result->fSMask = true;
     result->insertName("Type", "ExtGState");
     result->insert("SMask", sMaskDict.get());
 
     if (invert) {
         sMaskDict->insert("TR", new SkPDFObjRef(invertFunction.get()))->unref();
     }
 
     return result;
 }
 
 SkPDFGraphicState* SkPDFGraphicState::CreateNoSMaskGraphicState() {
     SkPDFGraphicState* noSMaskGS = SkNEW(SkPDFGraphicState);
     noSMaskGS->fPopulated = true;
-    noSMaskGS->fSMask = true;
     noSMaskGS->insertName("Type", "ExtGState");
     noSMaskGS->insertName("SMask", "None");
     return noSMaskGS;
 }
 
 SK_DECLARE_STATIC_LAZY_PTR(
         SkPDFGraphicState, noSMaskGraphicState,
         SkPDFGraphicState::CreateNoSMaskGraphicState, unref<SkPDFGraphicState>);
 
 // static
 SkPDFGraphicState* SkPDFGraphicState::GetNoSMaskGraphicState() {
     return SkRef(noSMaskGraphicState.get());
 }
 
 SkPDFGraphicState::SkPDFGraphicState()
-    : fPopulated(false),
-      fSMask(false) {
-}
+    : fCanon(NULL), fPopulated(false) {}
 
-SkPDFGraphicState::SkPDFGraphicState(const SkPaint& paint)
-    : fPaint(paint),
-      fPopulated(false),
-      fSMask(false) {
-}
+SkPDFGraphicState::SkPDFGraphicState(SkPDFCanon* canon, const SkPaint& paint)
+    : fCanon(canon), fPaint(paint), fPopulated(false) {}
 
 // populateDict and operator== have to stay in sync with each other.
 void SkPDFGraphicState::populateDict() {
     if (!fPopulated) {
         fPopulated = true;
         insertName("Type", "ExtGState");
 
         SkAutoTUnref<SkPDFScalar> alpha(
             new SkPDFScalar(SkScalarDiv(fPaint.getAlpha(), 0xFF)));
         insert("CA", alpha.get());
@@ skipping 23 matching lines @@
             fPaint.getXfermode()->asMode(&xfermode);
         // If we don't support the mode, just use kSrcOver_Mode.
         if (xfermode < 0 || xfermode > SkXfermode::kLastMode ||
             as_blend_mode(xfermode) == NULL) {
             xfermode = SkXfermode::kSrcOver_Mode;
             NOT_IMPLEMENTED("unsupported xfermode", false);
         }
         insertName("BM", as_blend_mode(xfermode));
     }
 }