Enforce thread-safety of bitmaps in pictures via the type.

src/core/SkRecords.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecords_DEFINED
 #define SkRecords_DEFINED
 
@@ skipping 165 matching lines @@
 
     ACT_AS_PTR(fPtr);
 private:
     T* fPtr;
 };
 
 #undef ACT_AS_PTR
 
 // Like SkBitmap, but deep copies pixels if they're not immutable.
 // Using this, we guarantee the immutability of all bitmaps we record.
-struct ImmutableBitmap : public SkBitmap {
+class ImmutableBitmap : SkNoncopyable {
+public:
     explicit ImmutableBitmap(const SkBitmap& bitmap) {
         if (bitmap.isImmutable()) {
-            *(SkBitmap*)this = bitmap;
+            fBitmap = bitmap;
         } else {
-            bitmap.copyTo(this);
+            bitmap.copyTo(&fBitmap);
         }
-        this->setImmutable();
+        fBitmap.setImmutable();
     }
+
+    int width()  const { return fBitmap.width();  }
+    int height() const { return fBitmap.height(); }
+
+    // While the pixels are immutable, SkBitmap itself is not thread-safe, so return a copy.
+    SkBitmap shallowCopy() const { return fBitmap; }
+private:
+    SkBitmap fBitmap;
 };
 
 // SkPath::getBounds() isn't thread safe unless we precache the bounds in a singlethreaded context.
 // Recording is a convenient time to do this, but we could delay it to between record and playback.
 struct BoundedPath : public SkPath {
     explicit BoundedPath(const SkPath& path) : SkPath(path) {
         this->updateBoundsCache();
     }
 };
 
@@ skipping 141 matching lines @@
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED