PDF: remove unnecessary mutexes.

src/pdf/SkPDFTypes.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 "SkPDFCatalog.h"
@@ skipping 294 matching lines @@
 
 SkPDFDict::SkPDFDict(const char type[]) {
     insertName("Type", type);
 }
 
 SkPDFDict::~SkPDFDict() {
     clear();
 }
 
 int SkPDFDict::size() const {
-    SkAutoMutexAcquire lock(fMutex);
     return fValue.count();
 }
 
 void SkPDFDict::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
-    SkAutoMutexAcquire lock(fMutex); // If another thread triggers a
-                                     // resize while this thread is in
-                                     // the for-loop, we can be left
-                                     // with a bad fValue[i] reference.
     stream->writeText("<<");
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
         fValue[i].key->emitObject(stream, catalog);
         stream->writeText(" ");
         catalog->getSubstituteObject(fValue[i].value)
                 ->emitObject(stream, catalog);
         stream->writeText("\n");
     }
     stream->writeText(">>");
 }
 
 void SkPDFDict::addResources(SkTSet<SkPDFObject*>* resourceSet,
                              SkPDFCatalog* catalog) const {
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
         fValue[i].key->addResources(resourceSet, catalog);
         catalog->getSubstituteObject(fValue[i].value)
                 ->addResources(resourceSet, catalog);
     }
 }
 
 SkPDFObject*  SkPDFDict::append(SkPDFName* key, SkPDFObject* value) {
     SkASSERT(key);
     SkASSERT(value);
-    SkAutoMutexAcquire lock(fMutex); // If the SkTDArray resizes while
-                                     // two threads access array, one
-                                     // is left with a bad pointer.
     *(fValue.append()) = Rec(key, value);
     return value;
 }
 
 SkPDFObject* SkPDFDict::insert(SkPDFName* key, SkPDFObject* value) {
     return this->append(SkRef(key), SkRef(value));
 }
 
 SkPDFObject* SkPDFDict::insert(const char key[], SkPDFObject* value) {
     return this->append(new SkPDFName(key), SkRef(value));
 }
 
 void SkPDFDict::insertInt(const char key[], int32_t value) {
     (void)this->append(new SkPDFName(key), new SkPDFInt(value));
 }
 
 void SkPDFDict::insertScalar(const char key[], SkScalar value) {
     (void)this->append(new SkPDFName(key), new SkPDFScalar(value));
 }
 
 void SkPDFDict::insertName(const char key[], const char name[]) {
     (void)this->append(new SkPDFName(key), new SkPDFName(name));
 }
 
 void SkPDFDict::clear() {
-    SkAutoMutexAcquire lock(fMutex);
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
         fValue[i].key->unref();
         fValue[i].value->unref();
     }
     fValue.reset();
 }
 
 void SkPDFDict::remove(const char key[]) {
     SkASSERT(key);
     SkPDFName name(key);
-    SkAutoMutexAcquire lock(fMutex);
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         if (*(fValue[i].key) == name) {
             fValue[i].key->unref();
             SkASSERT(fValue[i].value);
             fValue[i].value->unref();
             fValue.removeShuffle(i);
             return;
         }
     }
 }
 
 void SkPDFDict::mergeFrom(const SkPDFDict& other) {
-    SkAutoMutexAcquire lockOther(other.fMutex);
-    SkTDArray<Rec> copy(other.fValue);
-    lockOther.release();  // Do not hold both mutexes at once.
-
-    SkAutoMutexAcquire lock(fMutex);
-    for (int i = 0; i < copy.count(); i++) {
-        *(fValue.append()) = Rec(SkRef(copy[i].key), SkRef(copy[i].value));
+    for (int i = 0; i < other.fValue.count(); i++) {
+        *(fValue.append()) =
+                Rec(SkRef(other.fValue[i].key), SkRef(other.fValue[i].value));
     }
 }