cc: Remove PicturePile and PicturePileImpl.

cc/tiles/tile_manager_unittest.cc

 // Copyright 2013 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 "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/playback/display_list_raster_source.h"
 #include "cc/playback/display_list_recording_source.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/test/begin_frame_args_test.h"
+#include "cc/test/fake_display_list_raster_source.h"
 #include "cc/test/fake_display_list_recording_source.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
-#include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/fake_tile_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_tile_priorities.h"
 #include "cc/tiles/eviction_tile_priority_queue.h"
 #include "cc/tiles/raster_tile_priority_queue.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #include "cc/tiles/tiling_set_raster_queue_all.h"
 #include "cc/trees/layer_tree_impl.h"
@@ skipping 42 matching lines @@
   void SetUp() override {
     InitializeRenderer();
     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   }
 
   virtual void InitializeRenderer() {
     host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
-    gfx::Size tile_size(100, 100);
+    scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-    scoped_refptr<FakePicturePileImpl> pending_pile =
-        FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-    scoped_refptr<FakePicturePileImpl> active_pile =
-        FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-    SetupTrees(pending_pile, active_pile);
+    SetupTrees(pending_raster_source, active_raster_source);
   }
 
   // This matches picture_layer_impl_unittest's ActivateTree.
   void ActivateTree() {
     host_impl_.ActivateSyncTree();
     CHECK(!host_impl_.pending_tree());
     pending_layer_ = NULL;
     active_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.active_tree()->LayerById(id_));
     bool update_lcd_text = false;
     host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
   }
 
   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
                                           const gfx::Size& tile_size) {
     SetupDefaultTrees(layer_bounds);
     pending_layer_->set_fixed_tile_size(tile_size);
     active_layer_->set_fixed_tile_size(tile_size);
   }
 
-  void SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,
-                  scoped_refptr<PicturePileImpl> active_pile) {
-    SetupPendingTree(active_pile);
+  void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+                  scoped_refptr<RasterSource> active_raster_source) {
+    SetupPendingTree(active_raster_source);
     ActivateTree();
-    SetupPendingTree(pending_pile);
+    SetupPendingTree(pending_raster_source);
   }
 
-  void SetupPendingTree(scoped_refptr<RasterSource> pile) {
+  void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
     // Steal from the recycled tree.
     scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
     DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
 
     scoped_ptr<FakePictureLayerImpl> pending_layer;
     if (old_pending_root) {
       pending_layer.reset(
           static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
-      pending_layer->SetRasterSourceOnPending(pile, Region());
+      pending_layer->SetRasterSourceOnPending(raster_source, Region());
     } else {
-      pending_layer =
-          FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_, pile);
+      pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
+          pending_tree, id_, raster_source);
       pending_layer->SetDrawsContent(true);
       pending_layer->SetHasRenderSurface(true);
     }
-    // The bounds() just mirror the pile size.
+    // The bounds() just mirror the raster source size.
     pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
 
     // Add tilings/tiles for the layer.
     bool update_lcd_text = false;
     host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
   }
@@ skipping 445 matching lines @@
             actual_required_for_activation_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
   SetupDefaultTrees(layer_bounds);
 
   // Create a pending child layer.
-  gfx::Size tile_size(256, 256);
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   scoped_ptr<FakePictureLayerImpl> pending_child =
-      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(),
-                                                   id_ + 1, pending_pile);
+      FakePictureLayerImpl::CreateWithRasterSource(
+          host_impl_.pending_tree(), id_ + 1, pending_raster_source);
   FakePictureLayerImpl* pending_child_raw = pending_child.get();
   pending_child_raw->SetDrawsContent(true);
   pending_layer_->AddChild(pending_child.Pass());
 
   // Set a small viewport, so we have soon and eventually tiles.
   host_impl_.SetViewportSize(gfx::Size(200, 200));
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
@@ skipping 190 matching lines @@
   EXPECT_EQ(3, distance_increasing);
   EXPECT_EQ(16, distance_decreasing);
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        EvictionTilePriorityQueueWithOcclusion) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
 
   host_impl_.SetViewportSize(layer_bounds);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(pending_raster_source);
 
   scoped_ptr<FakePictureLayerImpl> pending_child =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
-                                                   pending_pile);
+                                                   pending_raster_source);
   pending_layer_->AddChild(pending_child.Pass());
 
   FakePictureLayerImpl* pending_child_layer =
       static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
   pending_child_layer->SetDrawsContent(true);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   ActivateTree();
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
 
   FakePictureLayerImpl* active_child_layer =
       static_cast<FakePictureLayerImpl*>(active_layer_->children()[0]);
 
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   while (!raster_queue->IsEmpty()) {
     ++tile_count;
@@ skipping 73 matching lines @@
     queue->Pop();
   }
   size_t expected_occluded_count = pending_child_high_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        EvictionTilePriorityQueueWithTransparentLayer) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(102, 102);

[danakj, 2015/09/22 21:52:15]

:D :D:D: D:D :D: :D :D :D :D :D :D :D :D:DDDDDDDDDDDDDD

   gfx::Size layer_bounds(1000, 1000);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(pending_raster_source);
 
   scoped_ptr<FakePictureLayerImpl> pending_child =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
-                                                   pending_pile);
+                                                   pending_raster_source);
   FakePictureLayerImpl* pending_child_layer = pending_child.get();
   pending_layer_->AddChild(pending_child.Pass());
 
   // Create a fully transparent child layer so that its tile priorities are not
   // considered to be valid.
   pending_child_layer->SetDrawsContent(true);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
@@ skipping 165 matching lines @@
   soon_rect.Inset(-inset, -inset);
 
   client.SetTileSize(gfx::Size(30, 30));
   LayerTreeSettings settings;
 
   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
       ACTIVE_TREE, &client, settings.tiling_interest_area_padding,
       settings.skewport_target_time_in_seconds,
       settings.skewport_extrapolation_limit_in_content_pixels);
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, pile);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling_set->UpdateTilePriorities(viewport, 1.0f, 1.0, Occlusion(), true);
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
   // Sanity check.
   EXPECT_EQ(3364u, all_tiles.size());
 
   // The explanation of each iteration is as follows:
   // 1. First iteration tests that we can get all of the tiles correctly.
   // 2. Second iteration ensures that we can get all of the tiles again (first
@@ skipping 86 matching lines @@
   gfx::Size layer_bounds(1000, 1000);
 
   client.SetTileSize(gfx::Size(30, 30));
   LayerTreeSettings settings;
 
   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
       ACTIVE_TREE, &client, settings.tiling_interest_area_padding,
       settings.skewport_target_time_in_seconds,
       settings.skewport_extrapolation_limit_in_content_pixels);
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, pile);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling_set->UpdateTilePriorities(viewport, 1.0f, 1.0, Occlusion(), true);
   tiling_set->UpdateTilePriorities(moved_viewport, 1.0f, 2.0, Occlusion(),
                                    true);
 
   float inset =
       PictureLayerTiling::CalculateSoonBorderDistance(moved_viewport, 1.0f);
   gfx::Rect soon_rect = moved_viewport;
   soon_rect.Inset(-inset, -inset);
@@ skipping 35 matching lines @@
   }
 
   EXPECT_GT(eventually_bin_order_correct_count,
             eventually_bin_order_incorrect_count);
 
   EXPECT_TRUE(have_tiles[TilePriority::NOW]);
   EXPECT_TRUE(have_tiles[TilePriority::SOON]);
   EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 }
 
-TEST_F(TileManagerTilePriorityQueueTest, SetIsLikelyToRequireADraw) {
+// TODO(vmpstr): Move these to LTHI tests, since they can't create real

[danakj, 2015/09/22 21:52:15]

Hm, the bug says we don't get up a real resource provider. What is fake exactly?
I think you should be able to get these to work. If you need pixel output you
could change the output surface to software, but I don't think that's the
problem. The upload doesn't need to work (TestContextProvider should work).

Do you have a callstack or sometihng?

[vmpstr, 2015/09/22 22:57:50]

The bug is just a guess at what's going on here. I'm just hoping to punt these
tests to a follow up. The only difference is that previously a picture pile
would analyze tiles as solid, and the display list raster source does not. 
[ RUN      ] TileManagerTilePriorityQueueTest.SetIsLikelyToRequireADraw
Received signal 11 SEGV_MAPERR 000000000000
#0 0x7fba84ab204e base::debug::StackTrace::StackTrace()
#1 0x7fba84ab1b8f base::debug::(anonymous namespace)::StackDumpSignalHandler()
#2 0x7fba822aa340 <unknown>
#3 0x7fba8505e87b cc::OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread()
#4 0x7fba850616de cc::(anonymous namespace)::RasterBufferImpl::Playback()
#5 0x7fba8511d019 cc::(anonymous namespace)::RasterTaskImpl::Raster()
#6 0x7fba8511c79c cc::(anonymous namespace)::RasterTaskImpl::RunOnWorkerThread()
#7 0x7fba8506ddfa cc::TaskGraphRunner::RunTaskWithLockAcquired()
#8 0x7fba8506d882 cc::TaskGraphRunner::Run()
#9 0x000000ecd135 cc::TestTaskGraphRunner::Run()
#10 0x7fba84be7bbf base::DelegateSimpleThread::Run()
#11 0x7fba84be7991 base::SimpleThread::ThreadMain()
#12 0x7fba84bd9d4a base::(anonymous namespace)::ThreadFunc()
#13 0x7fba822a2182 start_thread
#14 0x7fba81fcf47d clone
  r8: 0000000000000000  r9: c014d2cb5a509c00 r10: 0000000000000000 r11:
0000000000000001
 r12: 0000000000000000 r13: 0000000000000000 r14: c014d2cb5a509c00 r15:
00007fba7a344700
  di: 00007fba7a341c50  si: 00007fba7a341720  bp: 00007fba7a3428c0  bx:
00007fba7a341c58
  dx: 0000000000000000  ax: 0000000000000000  cx: 0000000000000000  sp:
00007fba7a341920
  ip: 00007fba8505e87b efl: 0000000000010202 cgf: 0000000000000033 erf:
0000000000000004
 trp: 000000000000000e msk: 00000000000

[danakj, 2015/09/22 23:04:06]

OK follow up is fine, but I just don't expect that these will have to move
anywhere. Maybe we can just make them solid color anyway too?

+// resources and so they don't work with non-solid raster sources.
+// crbug.com/534911
+TEST_F(TileManagerTilePriorityQueueTest, DISABLED_SetIsLikelyToRequireADraw) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
 
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
   EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
 }
 
+// TODO(vmpstr): Move these to LTHI tests, since they can't create real
+// resources and so they don't work with non-solid raster sources.
+// crbug.com/534911
 TEST_F(TileManagerTilePriorityQueueTest,
-       SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
+       DISABLED_SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
 
   ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
   policy.bytes_limit_when_visible = 0;
   host_impl_.SetMemoryPolicy(policy);
 
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
 }
 
+// TODO(vmpstr): Move these to LTHI tests, since they can't create real
+// resources and so they don't work with non-solid raster sources.
+// crbug.com/534911
 TEST_F(TileManagerTilePriorityQueueTest,
-       SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
+       DISABLED_SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
   EXPECT_EQ(gfx::Size(256, 256), queue->Top().tile()->desired_texture_size());
@@ skipping 15 matching lines @@
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
 
   host_impl_.resource_pool()->ReleaseResource(resource, 0);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterQueueAllUsesCorrectTileBounds) {
   // Verify that we use the real tile bounds when advancing phases during the
   // tile iteration.
   gfx::Size layer_bounds(1, 1);
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
   FakePictureLayerTilingClient pending_client;
   pending_client.SetTileSize(gfx::Size(64, 64));
 
   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
       WhichTree::ACTIVE_TREE, &pending_client, 1.0f, 1.0f, 1000);
   pending_client.set_twin_tiling_set(tiling_set.get());
 
-  auto* tiling = tiling_set->AddTiling(1.0f, pile);
+  auto* tiling = tiling_set->AddTiling(1.0f, raster_source);
 
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
 
   // The tile is (0, 0, 1, 1), create an intersecting and non-intersecting
   // rectangle to test the advance phase with. The tile size is (64, 64), so
   // both rectangles intersect the tile content size, but only one should
   // intersect the actual size.
   gfx::Rect non_intersecting_rect(2, 2, 10, 10);
   gfx::Rect intersecting_rect(0, 0, 10, 10);
@@ skipping 163 matching lines @@
           // background is not visible.
           ASSERT_EQ(SK_ColorBLUE, bitmap->getColor(x, y));
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace cc