Do not globally register drawables in test code

tests/FlattenDrawableTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDrawable.h"
 #include "SkOnce.h"
@@ skipping 61 matching lines @@
     static sk_sp<SkFlattenable> CreateProc(SkReadBuffer& buffer) {
         SkPaint paint;
         buffer.readPaint(&paint);
         return sk_sp<PaintDrawable>(new PaintDrawable(paint));
     }
 
     Factory getFactory() const override { return CreateProc; }
 
     const SkPaint& paint() const { return fPaint; }
 
+    const char* getTypeName() const override { return "PaintDrawable"; }
+
 protected:
     SkRect onGetBounds() override { return SkRect::MakeEmpty(); }
     void onDraw(SkCanvas*) override {}
 
 private:
     SkPaint fPaint;
 };
 
 class CompoundDrawable : public SkDrawable {
 public:
@@ skipping 25 matching lines @@
 
         return sk_sp<CompoundDrawable>(new CompoundDrawable((IntDrawable*) intDrawable.get(),
                                                             (PaintDrawable*) paintDrawable.get()));
     }
 
     Factory getFactory() const override { return CreateProc; }
 
     IntDrawable* intDrawable() const { return fIntDrawable; }
     PaintDrawable* paintDrawable() const { return fPaintDrawable; }
 
+    const char* getTypeName() const override { return "CompoundDrawable"; }
+
 protected:
     SkRect onGetBounds() override { return SkRect::MakeEmpty(); }
     void onDraw(SkCanvas*) override {}
 
 private:
     SkAutoTUnref<IntDrawable>   fIntDrawable;
     SkAutoTUnref<PaintDrawable> fPaintDrawable;
 };
 
 class RootDrawable : public SkDrawable {
@@ skipping 37 matching lines @@
                                                     (IntDrawable*) intDrawable.get(),
                                                     (SkDrawable*) drawable.get()));
     }
 
     Factory getFactory() const override { return CreateProc; }
 
     CompoundDrawable* compoundDrawable() const { return fCompoundDrawable; }
     IntDrawable* intDrawable() const { return fIntDrawable; }
     SkDrawable* drawable() const { return fDrawable; }
 
+    const char* getTypeName() const override { return "RootDrawable"; }
+
 protected:
     SkRect onGetBounds() override { return SkRect::MakeEmpty(); }
     void onDraw(SkCanvas*) override {}
 
 private:
     SkAutoTUnref<CompoundDrawable> fCompoundDrawable;
     SkAutoTUnref<IntDrawable>      fIntDrawable;
     SkAutoTUnref<SkDrawable>       fDrawable;
 };
 
-static void register_test_drawables() {
-    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(IntDrawable)
-    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(PaintDrawable)
-    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(CompoundDrawable)
-    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(RootDrawable)
-}
-
-static void register_test_drawables_once() {
-    static SkOnce once;
-    once(register_test_drawables);
+static void register_test_drawables(SkReadBuffer& buffer) {
+    buffer.setCustomFactory(SkString("IntDrawable"), IntDrawable::CreateProc);
+    buffer.setCustomFactory(SkString("PaintDrawable"), PaintDrawable::CreateProc);
+    buffer.setCustomFactory(SkString("CompoundDrawable"), CompoundDrawable::CreateProc);
+    buffer.setCustomFactory(SkString("RootDrawable"), RootDrawable::CreateProc);
 }
 
 DEF_TEST(FlattenDrawable, r) {
-    register_test_drawables_once();
-
     // Create and serialize the test drawable
     SkAutoTUnref<SkDrawable> drawable(new IntDrawable(1, 2, 3, 4));
     SkPaint paint;
     paint.setColor(SK_ColorBLUE);
     SkAutoTUnref<RootDrawable> root(new RootDrawable(5, 6, 7, 8, paint, 9, 10, 11, 12, drawable));
     SkWriteBuffer writeBuffer;
     writeBuffer.writeFlattenable(root);
 
     // Copy the contents of the write buffer into a read buffer
     sk_sp<SkData> data = SkData::MakeUninitialized(writeBuffer.bytesWritten());
     writeBuffer.writeToMemory(data->writable_data());
     SkReadBuffer readBuffer(data->data(), data->size());
+    register_test_drawables(readBuffer);
 
     // Deserialize and verify the drawable
     SkAutoTUnref<SkDrawable> out((SkDrawable*)
             readBuffer.readFlattenable(SkFlattenable::kSkDrawable_Type));
     REPORTER_ASSERT(r, out);
     REPORTER_ASSERT(r, !strcmp("RootDrawable", out->getTypeName()));
 
     RootDrawable* rootOut = (RootDrawable*) out.get();
     REPORTER_ASSERT(r, 5 == rootOut->compoundDrawable()->intDrawable()->a());
     REPORTER_ASSERT(r, 6 == rootOut->compoundDrawable()->intDrawable()->b());
@@ skipping 16 matching lines @@
     REPORTER_ASSERT(r, 4 == integer->d());
 }
 
 static sk_sp<SkFlattenable> custom_create_proc(SkReadBuffer& buffer) {
     sk_sp<SkFlattenable> drawable = IntDrawable::CreateProc(buffer);
     IntDrawable* intDrawable = (IntDrawable*) drawable.get();
     return sk_sp<IntDrawable>(new IntDrawable(intDrawable->a() + 1, intDrawable->b() + 1,
                                               intDrawable->c() + 1, intDrawable->d() + 1));
 }
 
 DEF_TEST(FlattenCustomDrawable, r) {

[mtklein, 2016/04/26 15:17:24]

Does this make this test moot?

[msarett, 2016/04/26 15:18:54]

Yes...  I'll delete this.

-    // No need to register the drawables since we will be using a custom proc.
-
     // Create and serialize the test drawable
     SkAutoTUnref<SkDrawable> drawable(new IntDrawable(1, 2, 3, 4));
     SkWriteBuffer writeBuffer;
     writeBuffer.writeFlattenable(drawable);
 
     // Copy the contents of the write buffer into a read buffer
     sk_sp<SkData> data = SkData::MakeUninitialized(writeBuffer.bytesWritten());
     writeBuffer.writeToMemory(data->writable_data());
     SkReadBuffer readBuffer(data->data(), data->size());
 
     // Register a custom factory with the read buffer
     readBuffer.setCustomFactory(SkString("IntDrawable"), &custom_create_proc);
 
     // Deserialize and verify the drawable
     SkAutoTUnref<IntDrawable> out((IntDrawable*)
             readBuffer.readFlattenable(SkFlattenable::kSkDrawable_Type));
     REPORTER_ASSERT(r, out);
     REPORTER_ASSERT(r, 2 == out->a());
     REPORTER_ASSERT(r, 3 == out->b());
     REPORTER_ASSERT(r, 4 == out->c());
     REPORTER_ASSERT(r, 5 == out->d());
 }