Add capture snapshot as data to SkWriter32, use it to optimise record->playback.

src/core/SkWriter32.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 "SkReader32.h"
 #include "SkString.h"
 #include "SkWriter32.h"
@@ skipping 56 matching lines @@
     const bool wasExternal = (fExternal != NULL) && (fData == fExternal);
 
     fCapacity = 4096 + SkTMax(size, fCapacity + (fCapacity / 2));
     fInternal.realloc(fCapacity);
     fData = fInternal.get();
 
     if (wasExternal) {
         // we were external, so copy in the data
         memcpy(fData, fExternal, fUsed);
     }
+    // Invalidate the snapshot, we know it is no longer useful.
+    fSnapshot.reset(NULL);
 }
+
+SK_DECLARE_STATIC_MUTEX(gSnapshotMutex);

[mtklein, 2014/03/06 18:58:08]

I think I'd be happier if we declared this to be not thread safe and didn't have
a mutex.

The complicated thing is that we use "threadsafe" as a shorthand for "safe to be
called as part of any sequence of method calls from any number of threads". 
We're ignoring all the other methods here; the only thing we're guaranteeing is
that no two threads can ever call snapshotAsData() at the same time.  That's
pretty limited protection, to the point where I'd rather have none, documented
as such.

This is probably another case where threadsafety is going to be best dealt with
at a higher level (e.g SkPicture{,Record,Playback}).

[iancottrell, 2014/03/06 21:31:52]

Done.

+
+SkData* SkWriter32::snapshotAsData() const {
+    SkAutoMutexAcquire am(gSnapshotMutex);
+    // get a non const version of this, we are only conceptually const
+    SkWriter32& self = *const_cast<SkWriter32*>(this);

[mtklein, 2014/03/06 18:58:08]

Maybe SkWriter32& self -> SkWriter32* mutable_this?

[iancottrell, 2014/03/06 21:31:52]

Done.

+    // we use size change detection to invalidate the cached data
+    if ((fSnapshot.get() != NULL) && (fSnapshot->size() != fUsed)) {
+        self.fSnapshot.reset(NULL);
+    }
+    if (fSnapshot.get() == NULL) {
+        uint8_t* buffer = NULL;
+        if ((fExternal != NULL) && (fData == fExternal)) {
+            // We need to copy to an allocated buffer before returning.
+            buffer = (uint8_t*)sk_malloc_throw(fUsed);
+            memcpy(buffer, fData, fUsed);
+        } else {
+            buffer = self.fInternal.detach();
+            // prepare us to do copy on write, by pretending the data buffer
+            // is external and size limited
+            self.fData = buffer;
+            self.fCapacity = fUsed;
+            self.fExternal = buffer;
+        }
+        self.fSnapshot.reset(SkData::NewFromMalloc(buffer, fUsed));
+    }
+    return SkRef(fSnapshot.get());

[mtklein, 2014/03/06 18:58:08]

Can you tack on // Take an extra ref for the caller.  ?  I stumbled over this a
second until I remembered the contract.

[iancottrell, 2014/03/06 21:31:52]

Done.

+}