Implement DisplayList GatherPixelRefs

cc/resources/recording_source_unittest.cc

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <vector>
+
+#include "cc/resources/display_list_raster_source.h"
+#include "cc/test/fake_display_list_recording_source.h"
+#include "cc/test/fake_picture_pile.h"
+#include "cc/test/fake_picture_pile_impl.h"
+#include "cc/test/impl_side_painting_settings.h"
+#include "cc/test/skia_common.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+template <class T>
+scoped_ptr<T> CreateRecordingSource(const gfx::Rect& viewport,
+                                    const gfx::Size& grid_cell_size);
+
+template <>
+scoped_ptr<FakePicturePile> CreateRecordingSource<FakePicturePile>(
+    const gfx::Rect& viewport,
+    const gfx::Size& grid_cell_size) {
+  return FakePicturePile::CreateFilledPile(grid_cell_size, viewport.size());
+}
+
+template <>
+scoped_ptr<FakeDisplayListRecordingSource> CreateRecordingSource<
+    FakeDisplayListRecordingSource>(const gfx::Rect& viewport,
+                                    const gfx::Size& grid_cell_size) {
+  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+      FakeDisplayListRecordingSource::CreateRecordingSource(viewport);
+  recording_source->SetGridCellSize(grid_cell_size);
+
+  return recording_source.Pass();
+}
+
+template <class T>
+scoped_refptr<RasterSource> CreateRasterSource(T* recording_source);
+
+template <>
+scoped_refptr<RasterSource> CreateRasterSource(
+    FakePicturePile* recording_source) {
+  return FakePicturePileImpl::CreateFromPile(recording_source, nullptr);
+}
+
+template <>
+scoped_refptr<RasterSource> CreateRasterSource(
+    FakeDisplayListRecordingSource* recording_source) {
+  bool can_use_lcd_text = true;
+  return DisplayListRasterSource::CreateFromDisplayListRecordingSource(
+      recording_source, can_use_lcd_text);
+}
+
+template <typename T>
+class RecordingSourceTest : public testing::Test {};
+
+using testing::Types;
+
+typedef Types<FakePicturePile, FakeDisplayListRecordingSource>
+    RecordingSourceImplementations;
+
+TYPED_TEST_CASE(RecordingSourceTest, RecordingSourceImplementations);
+
+TYPED_TEST(RecordingSourceTest, NoGatherPixelRefEmptyPixelRefs) {
+  gfx::Size grid_cell_size(128, 128);
+  gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+  scoped_ptr<TypeParam> recording_source =
+      CreateRecordingSource<TypeParam>(recorded_viewport, grid_cell_size);
+  recording_source->SetGatherPixelRefs(false);
+  recording_source->Rerecord();
+
+  scoped_refptr<RasterSource> raster_source =
+      CreateRasterSource<TypeParam>(recording_source.get());
+
+  // If recording source do not gather pixel ref, raster source is not going to
+  // get pixel refs.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(recorded_viewport, 1.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+}
+
+TYPED_TEST(RecordingSourceTest, EmptyPixelRefs) {
+  gfx::Size grid_cell_size(128, 128);
+  gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+  scoped_ptr<TypeParam> recording_source =
+      CreateRecordingSource<TypeParam>(recorded_viewport, grid_cell_size);
+  recording_source->SetGatherPixelRefs(true);
+  recording_source->Rerecord();
+
+  scoped_refptr<RasterSource> raster_source =
+      CreateRasterSource<TypeParam>(recording_source.get());
+
+  // Tile sized iterators.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 1.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 2.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 64, 64), 0.5, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  // Shifted tile sized iterators.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(140, 140, 128, 128), 1.0,
+                                   &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(280, 280, 256, 256), 2.0,
+                                   &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(70, 70, 64, 64), 0.5, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  // Layer sized iterators.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 1.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 512, 512), 2.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 0.5, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+}
+
+TYPED_TEST(RecordingSourceTest, NoDiscardablePixelRefs) {
+  gfx::Size grid_cell_size(128, 128);
+  gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+  scoped_ptr<TypeParam> recording_source =
+      CreateRecordingSource<TypeParam>(recorded_viewport, grid_cell_size);
+
+  SkPaint simple_paint;
+  simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
+
+  SkBitmap non_discardable_bitmap;
+  CreateBitmap(gfx::Size(128, 128), "notdiscardable", &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_bitmap(non_discardable_bitmap, gfx::Point(128, 0));
+  recording_source->add_draw_bitmap(non_discardable_bitmap, gfx::Point(0, 128));
+  recording_source->add_draw_bitmap(non_discardable_bitmap,
+                                    gfx::Point(150, 150));
+  recording_source->SetGatherPixelRefs(true);
+  recording_source->Rerecord();
+
+  scoped_refptr<RasterSource> raster_source =
+      CreateRasterSource<TypeParam>(recording_source.get());
+
+  // Tile sized iterators.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 1.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 2.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 64, 64), 0.5, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  // Shifted tile sized iterators.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(140, 140, 128, 128), 1.0,
+                                   &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(280, 280, 256, 256), 2.0,
+                                   &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(70, 70, 64, 64), 0.5, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  // Layer sized iterators.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 1.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 512, 512), 2.0, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 0.5, &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+}
+
+TYPED_TEST(RecordingSourceTest, DiscardablePixelRefs) {
+  gfx::Size grid_cell_size(128, 128);
+  gfx::Rect recorded_viewport(0, 0, 256, 256);
+
+  scoped_ptr<TypeParam> recording_source =
+      CreateRecordingSource<TypeParam>(recorded_viewport, grid_cell_size);
+
+  SkBitmap discardable_bitmap[2][2];
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[0][0]);
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[1][0]);
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[1][1]);
+
+  // Discardable pixel refs are found in the following cells:
+  // |---|---|
+  // | x |   |
+  // |---|---|
+  // | x | x |
+  // |---|---|
+  recording_source->add_draw_bitmap(discardable_bitmap[0][0], gfx::Point(0, 0));
+  recording_source->add_draw_bitmap(discardable_bitmap[1][0],
+                                    gfx::Point(0, 130));
+  recording_source->add_draw_bitmap(discardable_bitmap[1][1],
+                                    gfx::Point(140, 140));
+  recording_source->SetGatherPixelRefs(true);
+  recording_source->Rerecord();
+
+  scoped_refptr<RasterSource> raster_source =
+      CreateRasterSource<TypeParam>(recording_source.get());
+
+  // Tile sized iterators. These should find only one pixel ref.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 1.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 2.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 64, 64), 0.5, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+
+  // Shifted tile sized iterators. These should find only one pixel ref.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(140, 140, 128, 128), 1.0,
+                                   &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(280, 280, 256, 256), 2.0,
+                                   &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(70, 70, 64, 64), 0.5, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+
+  // Ensure there's no discardable pixel refs in the empty cell
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(140, 0, 128, 128), 1.0,
+                                   &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+
+  // Layer sized iterators. These should find all 3 pixel refs.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 1.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[1] == discardable_bitmap[1][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[2] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(3u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 512, 512), 2.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[1] == discardable_bitmap[1][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[2] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(3u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 0.5, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[1] == discardable_bitmap[1][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[2] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(3u, pixel_refs.size());
+  }
+}
+
+TYPED_TEST(RecordingSourceTest, DiscardablePixelRefsBaseNonDiscardable) {
+  gfx::Size grid_cell_size(256, 256);
+  gfx::Rect recorded_viewport(0, 0, 512, 512);
+
+  scoped_ptr<TypeParam> recording_source =
+      CreateRecordingSource<TypeParam>(recorded_viewport, grid_cell_size);
+
+  SkBitmap non_discardable_bitmap;
+  CreateBitmap(gfx::Size(512, 512), "notdiscardable", &non_discardable_bitmap);
+
+  SkBitmap discardable_bitmap[2][2];
+  CreateBitmap(gfx::Size(128, 128), "discardable", &discardable_bitmap[0][0]);
+  CreateBitmap(gfx::Size(128, 128), "discardable", &discardable_bitmap[0][1]);
+  CreateBitmap(gfx::Size(128, 128), "discardable", &discardable_bitmap[1][1]);
+
+  // One large non-discardable bitmap covers the whole grid.
+  // Discardable pixel refs are found in the following cells:
+  // |---|---|
+  // | x | x |
+  // |---|---|
+  // |   | x |
+  // |---|---|
+  recording_source->add_draw_bitmap(non_discardable_bitmap, gfx::Point(0, 0));
+  recording_source->add_draw_bitmap(discardable_bitmap[0][0], gfx::Point(0, 0));
+  recording_source->add_draw_bitmap(discardable_bitmap[0][1],
+                                    gfx::Point(260, 0));
+  recording_source->add_draw_bitmap(discardable_bitmap[1][1],
+                                    gfx::Point(260, 260));
+  recording_source->SetGatherPixelRefs(true);
+  recording_source->Rerecord();
+
+  scoped_refptr<RasterSource> raster_source =
+      CreateRasterSource<TypeParam>(recording_source.get());
+
+  // Tile sized iterators. These should find only one pixel ref.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 1.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 512, 512), 2.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 128, 128), 0.5, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  // Shifted tile sized iterators. These should find only one pixel ref.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(260, 260, 256, 256), 1.0,
+                                   &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(520, 520, 512, 512), 2.0,
+                                   &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(130, 130, 128, 128), 0.5,
+                                   &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(1u, pixel_refs.size());
+  }
+  // Ensure there's no discardable pixel refs in the empty cell
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 256, 256, 256), 1.0,
+                                   &pixel_refs);
+    EXPECT_TRUE(pixel_refs.empty());
+  }
+  // Layer sized iterators. These should find three pixel ref.
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 512, 512), 1.0, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[1] == discardable_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(pixel_refs[2] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(3u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 1024, 1024), 2.0,
+                                   &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[1] == discardable_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(pixel_refs[2] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(3u, pixel_refs.size());
+  }
+  {
+    std::vector<SkPixelRef*> pixel_refs;
+    raster_source->GatherPixelRefs(gfx::Rect(0, 0, 256, 256), 0.5, &pixel_refs);
+    EXPECT_FALSE(pixel_refs.empty());
+    EXPECT_TRUE(pixel_refs[0] == discardable_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(pixel_refs[1] == discardable_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(pixel_refs[2] == discardable_bitmap[1][1].pixelRef());
+    EXPECT_EQ(3u, pixel_refs.size());
+  }
+}
+
+}  // namespace
+}  // namespace cc