Restore bitmap dedup in SkPictureRecord. Cuts RAM usage of DM by half.

src/core/SkPictureRecord.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 "SkPictureRecord.h"
 #include "SkDevice.h"
 #include "SkPatchUtils.h"
@@ skipping 882 matching lines @@
 
     this->validate(initialOffset, size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSurface* SkPictureRecord::onNewSurface(const SkImageInfo& info, const SkSurfaceProps&) {
     return NULL;
 }
 
-int SkPictureRecord::addBitmap(const SkBitmap& bitmap) {
+static bool equivalent(const SkBitmap& a, const SkBitmap& b) {
+    if (a.info() != b.info() || a.pixelRefOrigin() != b.pixelRefOrigin()) {
+        return false;

[reed1, 2014/11/12 20:00:55]

wonder if we should just compare width/height instead of full info...

+    }
+    if (a.pixelRef() == b.pixelRef()) {
+        return true;
+    }
+    SkAutoLockPixels al(a), bl(b);

[reed1, 2014/11/12 20:00:56]

1. what if a or b is backed by a texture?
2. what if a or b fails to lock?
3. this will force any lazy images to be decoded :(

+    SkASSERT(a.getSize() == b.getSize());

[reed1, 2014/11/12 20:00:55]

a and b can have diff rowbytes, but be "logically" the same surface-area, hence
diff getSize() values (which incorporates rowbytes).

+    return 0 == memcmp(a.getPixels(), b.getPixels(), a.getSize());

[reed1, 2014/11/12 20:00:55]

per-scanline is the safe way, given a.rowbytes may != b.rowbytes

+}
+
+void SkPictureRecord::addBitmap(const SkBitmap& bitmap) {
+    // First see if we already have this bitmap.  This deduplication should really
+    // only be important for our tests, where bitmaps tend not to be tagged immutable.
+    // In Chrome (and hopefully Android?) they're typically immutable.
+    for (int i = 0; i < fBitmaps.count(); i++) {
+        if (equivalent(fBitmaps[i], bitmap)) {
+            this->addInt(i);  // Unlike the rest, bitmap indices are 0-based.
+            return;
+        }
+    }
+    // Don't have it.  We'll add it to our list, making sure it's tagged as immutable.
     if (bitmap.isImmutable()) {
+        // Shallow copies of bitmaps are cheap, so immutable == fast.
         fBitmaps.push_back(bitmap);
     } else {
+        // If you see this block on a memory profile, it's a good opportunity to reduce RAM usage.
         SkBitmap copy;
         bitmap.copyTo(&copy);
         copy.setImmutable();
         fBitmaps.push_back(copy);
     }
-    this->addInt(fBitmaps.count()-1);  // Unlike the rest, bitmap indicies are 0-based.
-    return fBitmaps.count();
+    this->addInt(fBitmaps.count()-1);  // Remember, 0-based.
 }
 
 void SkPictureRecord::addMatrix(const SkMatrix& matrix) {
     fWriter.writeMatrix(matrix);
 }
 
 void SkPictureRecord::addPaintPtr(const SkPaint* paint) {
     fContentInfo.onAddPaintPtr(paint);
 
     if (paint) {
@@ skipping 78 matching lines @@
 void SkPictureRecord::addTextBlob(const SkTextBlob *blob) {
     int index = fTextBlobRefs.count();
     *fTextBlobRefs.append() = blob;
     blob->ref();
     // follow the convention of recording a 1-based index
     this->addInt(index + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////