commit to xfermode objects being immutable

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkXfermode.h"
@@ skipping 1670 matching lines @@
 }
 
 #ifdef SK_DEVELOPER
 void SkDstOutXfermode::toString(SkString* str) const {
     this->INHERITED::toString(str);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkXfermode* SkXfermode::Create(Mode mode) {
-    SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
-    SkASSERT((unsigned)mode < kModeCount);
+static SkMutex gCachedXfermodesMutex;

[djsollen, 2013/10/04 14:48:28]

use SK_DECLARE_STATIC_MUTEX

+static SkXfermode* gCachedXfermodes[SkXfermode::kLastMode + 1];
 
-    const ProcCoeff& rec = gProcCoeffs[mode];
-
-    switch (mode) {
-        case kClear_Mode:
-            return SkNEW_ARGS(SkClearXfermode, (rec));
-        case kSrc_Mode:
-            return SkNEW_ARGS(SkSrcXfermode, (rec));
-        case kSrcOver_Mode:
-            return NULL;
-        case kDstIn_Mode:
-            return SkNEW_ARGS(SkDstInXfermode, (rec));
-        case kDstOut_Mode:
-            return SkNEW_ARGS(SkDstOutXfermode, (rec));
-        default:
-            return SkNEW_ARGS(SkProcCoeffXfermode, (rec, mode));
+void SkXfermode::Term() {
+    SkAutoMutexAcquire ac(gCachedXfermodesMutex);
+    
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gCachedXfermodes); ++i) {
+        SkSafeUnref(gCachedXfermodes[i]);
+        gCachedXfermodes[i] = NULL;
     }
 }
 
+SkXfermode* SkXfermode::Create(Mode mode) {
+    SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
+    SkASSERT(SK_ARRAY_COUNT(gCachedXfermodes) == kModeCount);
+    
+    if ((unsigned)mode >= kModeCount) {
+        // report error
+        return NULL;
+    }
+
+    if (kSrcOver_Mode == mode) {
+        return NULL;
+    }
+
+    // guard our access to gCachedXfermodes, since we may write into it
+    SkAutoMutexAcquire ac(gCachedXfermodesMutex);
+
+    SkXfermode* xfer = gCachedXfermodes[mode];
+    if (NULL == xfer) {
+        const ProcCoeff& rec = gProcCoeffs[mode];
+        switch (mode) {

[mtklein, 2013/10/04 15:07:01]

As someone who's not too familiar with this code, some things are tripping me
up:
  - why is kSrcOver special?
  - why do all the other modes get lumped into ProcCoeffXfermode?

I realize this isn't a logical change.  The original code confuses me too. :)

+            case kClear_Mode:
+                xfer = SkNEW_ARGS(SkClearXfermode, (rec));
+                break;
+            case kSrc_Mode:
+                xfer = SkNEW_ARGS(SkSrcXfermode, (rec));
+                break;
+            case kSrcOver_Mode:
+                SkASSERT(false);    // should not land here
+                break;
+            case kDstIn_Mode:
+                xfer = SkNEW_ARGS(SkDstInXfermode, (rec));
+                break;
+            case kDstOut_Mode:
+                xfer = SkNEW_ARGS(SkDstOutXfermode, (rec));
+                break;
+            default:
+                xfer = SkNEW_ARGS(SkProcCoeffXfermode, (rec, mode));
+                break;
+        }
+        gCachedXfermodes[mode] = xfer;
+    }
+    return SkSafeRef(xfer);
+}
+
 SkXfermodeProc SkXfermode::GetProc(Mode mode) {
     SkXfermodeProc  proc = NULL;
     if ((unsigned)mode < kModeCount) {
         proc = gProcCoeffs[mode].fProc;
     }
     return proc;
 }
 
 bool SkXfermode::ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst) {
     SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
@@ skipping 218 matching lines @@
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkClearXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSrcXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstInXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstOutXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END