Serialize DisplayListRecordingSource to protos.

cc/playback/display_list_recording_source_unittest.cc

Index: cc/playback/display_list_recording_source_unittest.cc
diff --git a/cc/playback/display_list_recording_source_unittest.cc b/cc/playback/display_list_recording_source_unittest.cc
index 7b4e24d8c021f9d7b3f53d938c1ab0bcdad80d99..eb066dc3d78395db00f888d9874a2beb6be3b016 100644
--- a/cc/playback/display_list_recording_source_unittest.cc
+++ b/cc/playback/display_list_recording_source_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "cc/base/region.h"
 #include "cc/playback/display_list_raster_source.h"
+#include "cc/proto/display_list_recording_source.pb.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_display_list_recording_source.h"
 #include "cc/test/skia_common.h"
@@ -14,364 +15,495 @@
 namespace cc {
 namespace {
 
-scoped_ptr<FakeDisplayListRecordingSource> CreateRecordingSource(
-    const gfx::Rect& viewport) {
-  gfx::Rect layer_rect(viewport.right(), viewport.bottom());
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      FakeDisplayListRecordingSource::CreateRecordingSource(viewport,
-                                                            layer_rect.size());
-  return recording_source;
+void PaintImageToPixels(const SkImageInfo& info,
+                        unsigned char* buffer,
+                        const SkImage* image) {
+  SkBitmap bitmap;
+  bitmap.installPixels(info, buffer, info.minRowBytes());
+  SkCanvas canvas(bitmap);
+  canvas.drawImage(image, 0, 0);
 }
 
-scoped_refptr<DisplayListRasterSource> CreateRasterSource(
-    FakeDisplayListRecordingSource* recording_source) {
-  bool can_use_lcd_text = true;
-  return DisplayListRasterSource::CreateFromDisplayListRecordingSource(
-      recording_source, can_use_lcd_text);
-}
-
-TEST(DisplayListRecordingSourceTest, DiscardableImagesWithTransform) {
-  gfx::Rect recorded_viewport(256, 256);
-
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
-          recorded_viewport.size());
-  skia::RefPtr<SkImage> discardable_image[2][2];
-  gfx::Transform identity_transform;
-  discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
-  // Translate transform is equivalent to moving using point.
-  gfx::Transform translate_transform;
-  translate_transform.Translate(0, 130);
-  discardable_image[1][0] = CreateDiscardableImage(gfx::Size(32, 32));
-  // This moves the bitmap to center of viewport and rotate, this would make
-  // this bitmap in all four tile grids.
-  gfx::Transform rotate_transform;
-  rotate_transform.Translate(112, 112);
-  rotate_transform.Rotate(45);
-  discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32));
-
-  gfx::RectF rect(0, 0, 32, 32);
-  gfx::RectF translate_rect = rect;
-  translate_transform.TransformRect(&translate_rect);
-  gfx::RectF rotate_rect = rect;
-  rotate_transform.TransformRect(&rotate_rect);
-
-  recording_source->add_draw_image_with_transform(discardable_image[0][0].get(),
-                                                  identity_transform);
-  recording_source->add_draw_image_with_transform(discardable_image[1][0].get(),
-                                                  translate_transform);
-  recording_source->add_draw_image_with_transform(discardable_image[1][1].get(),
-                                                  rotate_transform);
-  recording_source->SetGenerateDiscardableImagesMetadata(true);
-  recording_source->Rerecord();
-
-  bool can_use_lcd_text = true;
-  scoped_refptr<DisplayListRasterSource> raster_source =
-      DisplayListRasterSource::CreateFromDisplayListRecordingSource(
-          recording_source.get(), can_use_lcd_text);
-
-  // Tile sized iterators. These should find only one pixel ref.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
-                                              &images);
-    EXPECT_EQ(2u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
-    EXPECT_TRUE(images[1].image() == discardable_image[1][1].get());
-  }
+class DisplayListRecordingSourceTest : public testing::Test {
+ public:
+  DisplayListRecordingSourceTest() : test_serialization_(false) {}
 
-  // Shifted tile sized iterators. These should find only one pixel ref.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 140, 128, 128),
-                                              1.f, &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[1][1].get());
+ protected:
+  void RunTest(bool test_serialization) {
+    test_serialization_ = test_serialization;
+    StartTest();
   }
 
-  // The rotated bitmap would still be in the top right tile.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128), 1.f,
-                                              &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[1][1].get());
+  virtual void StartTest() = 0;
+
+  // Helper methods for building a FakeDisplayListRecordingSource.  Will
+  // properly turn off picture caching of the underlying DisplayItemList for
+  // tests that include serialization.
+  scoped_ptr<FakeDisplayListRecordingSource> CreateRecordingSource(

[David Trainor- moved to gerrit, 2015/12/09 04:07:24]

These are moved from the existing CreateRecordingSource,
CreateFilledRecordingSource, and CreateRasterSource helper methods that used to
exist outside the class.  I just added the if(test_serialization_) blocks.

+      const gfx::Rect& viewport) {
+    gfx::Rect layer_rect(viewport.right(), viewport.bottom());
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        FakeDisplayListRecordingSource::CreateRecordingSource(
+            viewport, layer_rect.size());
+    if (test_serialization_)
+      recording_source->SetDisplayListUsesCachedPicture(false);
+    return recording_source;
   }
 
-  // Layer sized iterators. These should find all pixel refs.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
-                                              &images);
-    EXPECT_EQ(3u, images.size());
-    // Top left tile with bitmap[0][0] and bitmap[1][1].
-    EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
-    EXPECT_TRUE(images[1].image() == discardable_image[1][0].get());
-    EXPECT_TRUE(images[2].image() == discardable_image[1][1].get());
+  scoped_ptr<FakeDisplayListRecordingSource> CreateFilledRecordingSource(
+      const gfx::Size& viewport_size) {
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+            viewport_size);
+    if (test_serialization_)
+      recording_source->SetDisplayListUsesCachedPicture(false);
+    return recording_source;
   }
 
-  // Verify different raster scales
-  for (float scale = 1.f; scale <= 5.f; scale += 0.5f) {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128),
-                                              scale, &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_FLOAT_EQ(scale, images[0].scale().width());
-    EXPECT_FLOAT_EQ(scale, images[0].scale().height());
-  }
-}
-
-TEST(DisplayListRecordingSourceTest, NoGatherImageEmptyImages) {
-  gfx::Rect recorded_viewport(0, 0, 256, 256);
-
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      CreateRecordingSource(recorded_viewport);
-  recording_source->SetGenerateDiscardableImagesMetadata(false);
-  recording_source->Rerecord();
-
-  scoped_refptr<DisplayListRasterSource> raster_source =
-      CreateRasterSource(recording_source.get());
-
-  // If recording source do not gather images, raster source is not going to
-  // get images.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(recorded_viewport, 1.f, &images);
-    EXPECT_TRUE(images.empty());
+  // Helper method for building a DisplayListRasterSource.  This will also
+  // serialize and deserialize the DisplayListRecordingSource if this test
+  // includes serialization.
+  scoped_refptr<DisplayListRasterSource> CreateRasterSource(
+      DisplayListRecordingSource* recording_source) {
+    scoped_ptr<DisplayListRecordingSource> deserialized;
+    if (test_serialization_) {
+      proto::DisplayListRecordingSource proto;
+      recording_source->ToProtobuf(&proto);
+
+      deserialized.reset(new FakeDisplayListRecordingSource);
+      deserialized->FromProtobuf(proto);
+      recording_source = deserialized.get();
+    }
+
+    bool can_use_lcd_text = true;
+    return DisplayListRasterSource::CreateFromDisplayListRecordingSource(
+        recording_source, can_use_lcd_text);
   }
-}
-
-TEST(DisplayListRecordingSourceTest, EmptyImages) {
-  gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      CreateRecordingSource(recorded_viewport);
-  recording_source->SetGenerateDiscardableImagesMetadata(true);
-  recording_source->Rerecord();
-
-  scoped_refptr<DisplayListRasterSource> raster_source =
-      CreateRasterSource(recording_source.get());
-
-  // Tile sized iterators.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
-                                              &images);
-    EXPECT_TRUE(images.empty());
-  }
-  // Shifted tile sized iterators.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
-                                              1.f, &images);
-    EXPECT_TRUE(images.empty());
+  // Helper method to validate that two SkImages are equal.  For the
+  // non-serialization case this will just compare the image pointers.  For the
+  // serialization case this will do a compare on the actual underlying rastered
+  // pixel data.
+  void ValidateEqualSkImages(const SkImage* image_a, const SkImage* image_b) {
+    if (!test_serialization_) {
+      EXPECT_TRUE(image_a == image_b);

[David Trainor- moved to gerrit, 2015/12/09 04:07:25]

This is how we used to validate that images were equal.  I'm keeping this for
the non-serialized version, but added a deep copy for the serialized version as
new images are created.

+      return;
+    }
+
+    EXPECT_TRUE(image_a->dimensions() == image_b->dimensions());
+    SkImageInfo info =
+        SkImageInfo::MakeN32Premul(image_a->width(), image_a->height());
+    const size_t pixel_size = info.minRowBytes() * info.height();
+    scoped_ptr<unsigned char[]> pixels_a(new unsigned char[pixel_size]);
+    scoped_ptr<unsigned char[]> pixels_b(new unsigned char[pixel_size]);
+
+    memset(pixels_a.get(), 0, pixel_size);
+    memset(pixels_b.get(), 0, pixel_size);
+
+    PaintImageToPixels(info, pixels_a.get(), image_a);
+    PaintImageToPixels(info, pixels_b.get(), image_b);
+
+    EXPECT_EQ(0, memcmp(pixels_a.get(), pixels_b.get(), pixel_size));
   }
-  // Layer sized iterators.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
-                                              &images);
-    EXPECT_TRUE(images.empty());
-  }
-}
 
-TEST(DisplayListRecordingSourceTest, NoDiscardableImages) {
-  gfx::Rect recorded_viewport(0, 0, 256, 256);
-
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      CreateRecordingSource(recorded_viewport);
-
-  SkPaint simple_paint;
-  simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
-
-  SkBitmap non_discardable_bitmap;
-  non_discardable_bitmap.allocN32Pixels(128, 128);
-  non_discardable_bitmap.setImmutable();
-  skia::RefPtr<SkImage> non_discardable_image =
-      skia::AdoptRef(SkImage::NewFromBitmap(non_discardable_bitmap));
-
-  recording_source->add_draw_rect_with_paint(gfx::Rect(0, 0, 256, 256),
-                                             simple_paint);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(128, 128, 512, 512),
-                                             simple_paint);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(512, 0, 256, 256),
-                                             simple_paint);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(0, 512, 256, 256),
-                                             simple_paint);
-  recording_source->add_draw_image(non_discardable_image.get(),
-                                   gfx::Point(128, 0));
-  recording_source->add_draw_image(non_discardable_image.get(),
-                                   gfx::Point(0, 128));
-  recording_source->add_draw_image(non_discardable_image.get(),
-                                   gfx::Point(150, 150));
-  recording_source->SetGenerateDiscardableImagesMetadata(true);
-  recording_source->Rerecord();
-
-  scoped_refptr<DisplayListRasterSource> raster_source =
-      CreateRasterSource(recording_source.get());
-
-  // Tile sized iterators.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
-                                              &images);
-    EXPECT_TRUE(images.empty());
+ private:
+  bool test_serialization_;
+};
+
+#define DIRECT_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunDirect) { RunTest(false); }
+
+#define SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunSerialized) { RunTest(true); }
+
+#define DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F( \
+    TEST_FIXTURE_NAME)                                              \
+  DIRECT_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(TEST_FIXTURE_NAME);   \
+  SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(TEST_FIXTURE_NAME)
+
+class DisplayListRecordingSourceTestDiscardableImagesWithTransform
+    : public DisplayListRecordingSourceTest {
+ protected:
+  void StartTest() override {

[David Trainor- moved to gerrit, 2015/12/09 04:07:24]

All of these tests should be roughly the same as the other counterparts.  I
changed how we validated images and moved all of the recording/raster source
creation calls to the helper methods.

+    gfx::Rect recorded_viewport(256, 256);
+
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        CreateFilledRecordingSource(recorded_viewport.size());
+
+    skia::RefPtr<SkImage> discardable_image[2][2];
+    gfx::Transform identity_transform;
+    discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
+    // Translate transform is equivalent to moving using point.
+    gfx::Transform translate_transform;
+    translate_transform.Translate(0, 130);
+    discardable_image[1][0] = CreateDiscardableImage(gfx::Size(32, 32));
+    // This moves the bitmap to center of viewport and rotate, this would make
+    // this bitmap in all four tile grids.
+    gfx::Transform rotate_transform;
+    rotate_transform.Translate(112, 112);
+    rotate_transform.Rotate(45);
+    discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32));
+
+    gfx::RectF rect(0, 0, 32, 32);
+    gfx::RectF translate_rect = rect;
+    translate_transform.TransformRect(&translate_rect);
+    gfx::RectF rotate_rect = rect;
+    rotate_transform.TransformRect(&rotate_rect);
+
+    recording_source->add_draw_image_with_transform(
+        discardable_image[0][0].get(), identity_transform);
+    recording_source->add_draw_image_with_transform(
+        discardable_image[1][0].get(), translate_transform);
+    recording_source->add_draw_image_with_transform(
+        discardable_image[1][1].get(), rotate_transform);
+    recording_source->SetGenerateDiscardableImagesMetadata(true);
+    recording_source->Rerecord();
+
+    scoped_refptr<DisplayListRasterSource> raster_source =
+        CreateRasterSource(recording_source.get());
+
+    // Tile sized iterators. These should find only one pixel ref.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                                &images);
+      EXPECT_EQ(2u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[0][0].get());
+      ValidateEqualSkImages(images[1].image(), discardable_image[1][1].get());
+    }
+
+    // Shifted tile sized iterators. These should find only one pixel ref.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 140, 128, 128),
+                                                1.f, &images);
+      EXPECT_EQ(1u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[1][1].get());
+    }
+
+    // The rotated bitmap would still be in the top right tile.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128),
+                                                1.f, &images);
+      EXPECT_EQ(1u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[1][1].get());
+    }
+
+    // Layer sized iterators. These should find all pixel refs.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                                &images);
+      EXPECT_EQ(3u, images.size());
+      // Top left tile with bitmap[0][0] and bitmap[1][1].
+      ValidateEqualSkImages(images[0].image(), discardable_image[0][0].get());
+      ValidateEqualSkImages(images[1].image(), discardable_image[1][0].get());
+      ValidateEqualSkImages(images[2].image(), discardable_image[1][1].get());
+    }
+
+    // Verify different raster scales
+    for (float scale = 1.f; scale <= 5.f; scale += 0.5f) {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128),
+                                                scale, &images);
+      EXPECT_EQ(1u, images.size());
+      EXPECT_FLOAT_EQ(scale, images[0].scale().width());
+      EXPECT_FLOAT_EQ(scale, images[0].scale().height());
+    }
   }
-  // Shifted tile sized iterators.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
-                                              1.f, &images);
-    EXPECT_TRUE(images.empty());
+};
+
+DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(
+    DisplayListRecordingSourceTestDiscardableImagesWithTransform);
+
+class DisplayListRecordingSourceTestNoGatherImageEmptyImages
+    : public DisplayListRecordingSourceTest {
+ protected:
+  void StartTest() override {
+    gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        CreateRecordingSource(recorded_viewport);
+    recording_source->SetGenerateDiscardableImagesMetadata(false);
+    recording_source->Rerecord();
+
+    scoped_refptr<DisplayListRasterSource> raster_source =
+        CreateRasterSource(recording_source.get());
+
+    // If recording source do not gather images, raster source is not going to
+    // get images.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(recorded_viewport, 1.f,
+                                                &images);
+      EXPECT_TRUE(images.empty());
+    }
   }
-  // Layer sized iterators.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
-                                              &images);
-    EXPECT_TRUE(images.empty());
+};
+
+DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(
+    DisplayListRecordingSourceTestNoGatherImageEmptyImages);
+
+class DisplayListRecordingSourceTestEmptyImages
+    : public DisplayListRecordingSourceTest {
+ protected:
+  void StartTest() override {
+    gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        CreateRecordingSource(recorded_viewport);
+    recording_source->SetGenerateDiscardableImagesMetadata(true);
+    recording_source->Rerecord();
+
+    scoped_refptr<DisplayListRasterSource> raster_source =
+        CreateRasterSource(recording_source.get());
+
+    // Tile sized iterators.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                                &images);
+      EXPECT_TRUE(images.empty());
+    }
+    // Shifted tile sized iterators.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
+                                                1.f, &images);
+      EXPECT_TRUE(images.empty());
+    }
+    // Layer sized iterators.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                                &images);
+      EXPECT_TRUE(images.empty());
+    }
   }
-}
-
-TEST(DisplayListRecordingSourceTest, DiscardableImages) {
-  gfx::Rect recorded_viewport(0, 0, 256, 256);
-
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      CreateRecordingSource(recorded_viewport);
-
-  skia::RefPtr<SkImage> discardable_image[2][2];
-  discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
-  discardable_image[1][0] = CreateDiscardableImage(gfx::Size(32, 32));
-  discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32));
-
-  // Discardable images are found in the following cells:
-  // |---|---|
-  // | x |   |
-  // |---|---|
-  // | x | x |
-  // |---|---|
-  recording_source->add_draw_image(discardable_image[0][0].get(),
-                                   gfx::Point(0, 0));
-  recording_source->add_draw_image(discardable_image[1][0].get(),
-                                   gfx::Point(0, 130));
-  recording_source->add_draw_image(discardable_image[1][1].get(),
-                                   gfx::Point(140, 140));
-  recording_source->SetGenerateDiscardableImagesMetadata(true);
-  recording_source->Rerecord();
-
-  scoped_refptr<DisplayListRasterSource> raster_source =
-      CreateRasterSource(recording_source.get());
-
-  // Tile sized iterators. These should find only one image.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
-                                              &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
+};
+
+DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(
+    DisplayListRecordingSourceTestEmptyImages);
+
+class DisplayListRecordingSourceTestNoDiscardableImages

[David Trainor- moved to gerrit, 2015/12/09 04:07:25]

Failing in serialized mode.  Investigating.

+    : public DisplayListRecordingSourceTest {
+ protected:
+  void StartTest() override {
+    gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        CreateRecordingSource(recorded_viewport);
+
+    SkPaint simple_paint;
+    simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
+
+    SkBitmap non_discardable_bitmap;
+    non_discardable_bitmap.allocN32Pixels(128, 128);
+    non_discardable_bitmap.setImmutable();
+    skia::RefPtr<SkImage> non_discardable_image =
+        skia::AdoptRef(SkImage::NewFromBitmap(non_discardable_bitmap));
+
+    recording_source->add_draw_rect_with_paint(gfx::Rect(0, 0, 256, 256),
+                                               simple_paint);
+    recording_source->add_draw_rect_with_paint(gfx::Rect(128, 128, 512, 512),
+                                               simple_paint);
+    recording_source->add_draw_rect_with_paint(gfx::Rect(512, 0, 256, 256),
+                                               simple_paint);
+    recording_source->add_draw_rect_with_paint(gfx::Rect(0, 512, 256, 256),
+                                               simple_paint);
+    recording_source->add_draw_image(non_discardable_image.get(),
+                                     gfx::Point(128, 0));
+    recording_source->add_draw_image(non_discardable_image.get(),
+                                     gfx::Point(0, 128));
+    recording_source->add_draw_image(non_discardable_image.get(),
+                                     gfx::Point(150, 150));
+    recording_source->SetGenerateDiscardableImagesMetadata(true);
+    recording_source->Rerecord();
+
+    scoped_refptr<DisplayListRasterSource> raster_source =
+        CreateRasterSource(recording_source.get());
+
+    // Tile sized iterators.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                                &images);
+      EXPECT_TRUE(images.empty());
+    }
+    // Shifted tile sized iterators.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
+                                                1.f, &images);
+      EXPECT_TRUE(images.empty());
+    }
+    // Layer sized iterators.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                                &images);
+      EXPECT_TRUE(images.empty());
+    }
   }
-
-  // Shifted tile sized iterators. These should find only one image.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
-                                              1.f, &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[1][1].get());
-  }
-
-  // Ensure there's no discardable images in the empty cell
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 0, 128, 128), 1.f,
-                                              &images);
-    EXPECT_TRUE(images.empty());
+};
+
+DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(
+    DisplayListRecordingSourceTestNoDiscardableImages);
+
+class DisplayListRecordingSourceTestDiscardableImages
+    : public DisplayListRecordingSourceTest {
+ protected:
+  void StartTest() override {
+    gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        CreateRecordingSource(recorded_viewport);
+
+    skia::RefPtr<SkImage> discardable_image[2][2];
+    discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
+    discardable_image[1][0] = CreateDiscardableImage(gfx::Size(32, 32));
+    discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32));
+
+    // Discardable images are found in the following cells:
+    // |---|---|
+    // | x |   |
+    // |---|---|
+    // | x | x |
+    // |---|---|
+    recording_source->add_draw_image(discardable_image[0][0].get(),
+                                     gfx::Point(0, 0));
+    recording_source->add_draw_image(discardable_image[1][0].get(),
+                                     gfx::Point(0, 130));
+    recording_source->add_draw_image(discardable_image[1][1].get(),
+                                     gfx::Point(140, 140));
+    recording_source->SetGenerateDiscardableImagesMetadata(true);
+    recording_source->Rerecord();
+
+    scoped_refptr<DisplayListRasterSource> raster_source =
+        CreateRasterSource(recording_source.get());
+
+    // Tile sized iterators. These should find only one image.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                                &images);
+      EXPECT_EQ(1u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[0][0].get());
+    }
+
+    // Shifted tile sized iterators. These should find only one image.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
+                                                1.f, &images);
+      EXPECT_EQ(1u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[1][1].get());
+    }
+
+    // Ensure there's no discardable images in the empty cell
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 0, 128, 128),
+                                                1.f, &images);
+      EXPECT_TRUE(images.empty());
+    }
+
+    // Layer sized iterators. These should find all 3 images.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                                &images);
+      EXPECT_EQ(3u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[0][0].get());
+      ValidateEqualSkImages(images[1].image(), discardable_image[1][0].get());
+      ValidateEqualSkImages(images[2].image(), discardable_image[1][1].get());
+    }
   }
-
-  // Layer sized iterators. These should find all 3 images.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
-                                              &images);
-    EXPECT_EQ(3u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
-    EXPECT_TRUE(images[1].image() == discardable_image[1][0].get());
-    EXPECT_TRUE(images[2].image() == discardable_image[1][1].get());
+};
+
+DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(
+    DisplayListRecordingSourceTestDiscardableImages);
+
+class DisplayListRecordingSourceTestDiscardableImagesBaseNonDiscardable

[David Trainor- moved to gerrit, 2015/12/09 04:07:24]

Failing in serialized mode.  Investigating.

+    : public DisplayListRecordingSourceTest {
+ protected:
+  void StartTest() override {
+    gfx::Rect recorded_viewport(0, 0, 512, 512);
+
+    scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+        CreateRecordingSource(recorded_viewport);
+
+    SkBitmap non_discardable_bitmap;
+    non_discardable_bitmap.allocN32Pixels(512, 512);
+    non_discardable_bitmap.setImmutable();
+    skia::RefPtr<SkImage> non_discardable_image =
+        skia::AdoptRef(SkImage::NewFromBitmap(non_discardable_bitmap));
+
+    skia::RefPtr<SkImage> discardable_image[2][2];
+    discardable_image[0][0] = CreateDiscardableImage(gfx::Size(128, 128));
+    discardable_image[0][1] = CreateDiscardableImage(gfx::Size(128, 128));
+    discardable_image[1][1] = CreateDiscardableImage(gfx::Size(128, 128));
+
+    // One large non-discardable image covers the whole grid.
+    // Discardable images are found in the following cells:
+    // |---|---|
+    // | x | x |
+    // |---|---|
+    // |   | x |
+    // |---|---|
+    recording_source->add_draw_image(non_discardable_image.get(),
+                                     gfx::Point(0, 0));
+    recording_source->add_draw_image(discardable_image[0][0].get(),
+                                     gfx::Point(0, 0));
+    recording_source->add_draw_image(discardable_image[0][1].get(),
+                                     gfx::Point(260, 0));
+    recording_source->add_draw_image(discardable_image[1][1].get(),
+                                     gfx::Point(260, 260));
+    recording_source->SetGenerateDiscardableImagesMetadata(true);
+    recording_source->Rerecord();
+
+    scoped_refptr<DisplayListRasterSource> raster_source =
+        CreateRasterSource(recording_source.get());
+
+    // Tile sized iterators. These should find only one image.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                                &images);
+      EXPECT_EQ(1u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[0][0].get());
+    }
+    // Shifted tile sized iterators. These should find only one image.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(260, 260, 256, 256),
+                                                1.f, &images);
+      EXPECT_EQ(1u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[1][1].get());
+    }
+    // Ensure there's no discardable images in the empty cell
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 256, 256, 256),
+                                                1.f, &images);
+      EXPECT_TRUE(images.empty());
+    }
+    // Layer sized iterators. These should find three images.
+    {
+      std::vector<DrawImage> images;
+      raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 512, 512), 1.f,
+                                                &images);
+      EXPECT_EQ(3u, images.size());
+      ValidateEqualSkImages(images[0].image(), discardable_image[0][0].get());
+      ValidateEqualSkImages(images[1].image(), discardable_image[0][1].get());
+      ValidateEqualSkImages(images[2].image(), discardable_image[1][1].get());
+    }
   }
-}
+};
 
-TEST(DisplayListRecordingSourceTest, DiscardableImagesBaseNonDiscardable) {
-  gfx::Rect recorded_viewport(0, 0, 512, 512);
-
-  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
-      CreateRecordingSource(recorded_viewport);
-
-  SkBitmap non_discardable_bitmap;
-  non_discardable_bitmap.allocN32Pixels(512, 512);
-  non_discardable_bitmap.setImmutable();
-  skia::RefPtr<SkImage> non_discardable_image =
-      skia::AdoptRef(SkImage::NewFromBitmap(non_discardable_bitmap));
-
-  skia::RefPtr<SkImage> discardable_image[2][2];
-  discardable_image[0][0] = CreateDiscardableImage(gfx::Size(128, 128));
-  discardable_image[0][1] = CreateDiscardableImage(gfx::Size(128, 128));
-  discardable_image[1][1] = CreateDiscardableImage(gfx::Size(128, 128));
-
-  // One large non-discardable image covers the whole grid.
-  // Discardable images are found in the following cells:
-  // |---|---|
-  // | x | x |
-  // |---|---|
-  // |   | x |
-  // |---|---|
-  recording_source->add_draw_image(non_discardable_image.get(),
-                                   gfx::Point(0, 0));
-  recording_source->add_draw_image(discardable_image[0][0].get(),
-                                   gfx::Point(0, 0));
-  recording_source->add_draw_image(discardable_image[0][1].get(),
-                                   gfx::Point(260, 0));
-  recording_source->add_draw_image(discardable_image[1][1].get(),
-                                   gfx::Point(260, 260));
-  recording_source->SetGenerateDiscardableImagesMetadata(true);
-  recording_source->Rerecord();
-
-  scoped_refptr<DisplayListRasterSource> raster_source =
-      CreateRasterSource(recording_source.get());
-
-  // Tile sized iterators. These should find only one image.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
-                                              &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
-  }
-  // Shifted tile sized iterators. These should find only one image.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(260, 260, 256, 256),
-                                              1.f, &images);
-    EXPECT_EQ(1u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[1][1].get());
-  }
-  // Ensure there's no discardable images in the empty cell
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 256, 256, 256), 1.f,
-                                              &images);
-    EXPECT_TRUE(images.empty());
-  }
-  // Layer sized iterators. These should find three images.
-  {
-    std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 512, 512), 1.f,
-                                              &images);
-    EXPECT_EQ(3u, images.size());
-    EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
-    EXPECT_TRUE(images[1].image() == discardable_image[0][1].get());
-    EXPECT_TRUE(images[2].image() == discardable_image[1][1].get());
-  }
-}
+DIRECT_AND_SERIALIZED_DISPLAY_LIST_RECORDING_SOURCE_TEST_F(
+    DisplayListRecordingSourceTestDiscardableImagesBaseNonDiscardable);
 
 }  // namespace
 }  // namespace cc