dedup images/blobs/pictures by ID in old serialization format

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 "SkImage_Base.h"
 #include "SkPatchUtils.h"
@@ skipping 849 matching lines @@
 
     size_t initialOffset = this->addDraw(DRAW_ANNOTATION, &size);
     this->addRect(rect);
     fWriter.writeString(key);
     fWriter.writeData(value);
     this->validate(initialOffset, size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+template <typename T> int find_or_append_uniqueID(SkTDArray<const T*>& array, const T* obj) {
+    int index = array.select([&](const T* elem) {
+        return elem->uniqueID() == obj->uniqueID();
+    });
+    if (index < 0) {
+        index = array.count();

[mtklein, 2016/08/29 14:34:46]

Seems like we could return count instead of -1, so this becomes

if (index == array.count()) {
  *array.append() = SkRef(obj);
}
return index;

[reed1, 2016/08/29 14:41:26]

That would make this site a tiny bit simpler, but I was following the previous
convention for find() which returns negative on failure. For me this makes
callers slightly simpler in general, since they don't need to always query
count() to know if it failed.

If we decide to return count() instead, I'd vote for also changing find()'s
convention (and updating its callers) to keep find and select consistent.

+        *array.append() = SkRef(obj);
+    }
+    return index;
+}
+
 sk_sp<SkSurface> SkPictureRecord::onNewSurface(const SkImageInfo& info, const SkSurfaceProps&) {
     return nullptr;
 }
 
 void SkPictureRecord::addImage(const SkImage* image) {
-    int index = fImageRefs.find(image);
-    if (index >= 0) {
-        this->addInt(index);
-    } else {
-        *fImageRefs.append() = SkRef(image);
-        this->addInt(fImageRefs.count()-1);
-    }
+    // convention for images is 0-based index
+    this->addInt(find_or_append_uniqueID(fImageRefs, image));
 }
 
 void SkPictureRecord::addMatrix(const SkMatrix& matrix) {
     fWriter.writeMatrix(matrix);
 }
 
 void SkPictureRecord::addPaintPtr(const SkPaint* paint) {
     fContentInfo.onAddPaintPtr(paint);
 
     if (paint) {
@@ skipping 15 matching lines @@
 
 void SkPictureRecord::addPath(const SkPath& path) {
     this->addInt(this->addPathToHeap(path));
 }
 
 void SkPictureRecord::addPatch(const SkPoint cubics[12]) {
     fWriter.write(cubics, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint));
 }
 
 void SkPictureRecord::addPicture(const SkPicture* picture) {
-    int index = fPictureRefs.find(picture);
-    if (index < 0) {    // not found
-        index = fPictureRefs.count();
-        *fPictureRefs.append() = picture;
-        picture->ref();
-    }
     // follow the convention of recording a 1-based index
-    this->addInt(index + 1);
+    this->addInt(find_or_append_uniqueID(fPictureRefs, picture) + 1);
 }
 
 void SkPictureRecord::addDrawable(SkDrawable* drawable) {
     int index = fDrawableRefs.find(drawable);
     if (index < 0) {    // not found
         index = fDrawableRefs.count();
         *fDrawableRefs.append() = drawable;
         drawable->ref();
     }
     // follow the convention of recording a 1-based index
@@ skipping 40 matching lines @@
 void SkPictureRecord::addRegion(const SkRegion& region) {
     fWriter.writeRegion(region);
 }
 
 void SkPictureRecord::addText(const void* text, size_t byteLength) {
     fContentInfo.onDrawText();
     addInt(SkToInt(byteLength));
     fWriter.writePad(text, byteLength);
 }
 
-void SkPictureRecord::addTextBlob(const SkTextBlob *blob) {
-    int index = fTextBlobRefs.count();
-    *fTextBlobRefs.append() = blob;
-    blob->ref();
+void SkPictureRecord::addTextBlob(const SkTextBlob* blob) {
     // follow the convention of recording a 1-based index
-    this->addInt(index + 1);
+    this->addInt(find_or_append_uniqueID(fTextBlobRefs, blob) + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////