cc: Rework how picture layer tiling set gets into raster queues.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 60 matching lines @@
 namespace {
 
 class LayerTreeHostTest : public LayerTreeTest {};
 
 // Test if the LTHI receives ReadyToActivate notifications from the TileManager
 // when no raster tasks get scheduled.
 class LayerTreeHostTestReadyToActivateEmpty : public LayerTreeHostTest {
  public:
   LayerTreeHostTestReadyToActivateEmpty()
       : did_notify_ready_to_activate_(false),
-        all_tiles_required_for_activation_are_ready_to_draw_(false),
-        required_for_activation_count_(0) {}
+        all_tiles_required_for_activation_are_ready_to_draw_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
-    const std::vector<PictureLayerImpl*>& layers = impl->GetPictureLayers();
-    required_for_activation_count_ = 0;
-    for (const auto& layer : layers) {
-      FakePictureLayerImpl* fake_layer =
-          static_cast<FakePictureLayerImpl*>(layer);
-      required_for_activation_count_ +=
-          fake_layer->CountTilesRequiredForActivation();
-    }
+    bool ready_to_activate_on_commit_complete =
+        impl->tile_manager()->IsReadyToActivate();
+    // This being true means that we have no tiles required for activation
+    // (since we had no time to prepare any tiles if they were required for
+    // activation).
+    EXPECT_TRUE(ready_to_activate_on_commit_complete);
   }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
     did_notify_ready_to_activate_ = true;
     all_tiles_required_for_activation_are_ready_to_draw_ =
         impl->tile_manager()->IsReadyToActivate();
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
-    EXPECT_EQ(size_t(0), required_for_activation_count_);
   }
 
- protected:
+ private:
   bool did_notify_ready_to_activate_;
   bool all_tiles_required_for_activation_are_ready_to_draw_;
-  size_t required_for_activation_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestReadyToActivateEmpty);
 
 // Test if the LTHI receives ReadyToActivate notifications from the TileManager
 // when some raster tasks flagged as REQUIRED_FOR_ACTIVATION got scheduled.
-class LayerTreeHostTestReadyToActivateNonEmpty
-    : public LayerTreeHostTestReadyToActivateEmpty {
+class LayerTreeHostTestReadyToActivateNonEmpty : public LayerTreeHostTest {
  public:
+  LayerTreeHostTestReadyToActivateNonEmpty()
+      : did_notify_ready_to_activate_(false),
+        all_tiles_required_for_activation_are_ready_to_draw_(false) {}
+
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
+    did_notify_ready_to_activate_ = true;
+    all_tiles_required_for_activation_are_ready_to_draw_ =
+        impl->tile_manager()->IsReadyToActivate();
+    EndTest();
+  }
+
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
-    EXPECT_LE(size_t(1), required_for_activation_count_);
   }
 
  private:
   FakeContentLayerClient client_;
+  bool did_notify_ready_to_activate_;
+  bool all_tiles_required_for_activation_are_ready_to_draw_;
 };
 
 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestReadyToActivateNonEmpty);
 
 // Test if the LTHI receives ReadyToDraw notifications from the TileManager when
 // no raster tasks get scheduled.
 class LayerTreeHostTestReadyToDrawEmpty : public LayerTreeHostTest {
  public:
   LayerTreeHostTestReadyToDrawEmpty()
       : did_notify_ready_to_draw_(false),
-        all_tiles_required_for_draw_are_ready_to_draw_(false),
-        required_for_draw_count_(0) {}
+        all_tiles_required_for_draw_are_ready_to_draw_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void NotifyReadyToDrawOnThread(LayerTreeHostImpl* impl) override {
     did_notify_ready_to_draw_ = true;
-    const std::vector<PictureLayerImpl*>& layers = impl->GetPictureLayers();
     all_tiles_required_for_draw_are_ready_to_draw_ =
         impl->tile_manager()->IsReadyToDraw();
-    for (const auto& layer : layers) {
-      FakePictureLayerImpl* fake_layer =
-          static_cast<FakePictureLayerImpl*>(layer);
-      required_for_draw_count_ += fake_layer->CountTilesRequiredForDraw();
-    }
-
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
     EXPECT_TRUE(all_tiles_required_for_draw_are_ready_to_draw_);
-    EXPECT_EQ(size_t(0), required_for_draw_count_);
   }
 
- protected:
+ private:
   bool did_notify_ready_to_draw_;
   bool all_tiles_required_for_draw_are_ready_to_draw_;
-  size_t required_for_draw_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestReadyToDrawEmpty);
 
 // Test if the LTHI receives ReadyToDraw notifications from the TileManager when
 // some raster tasks flagged as REQUIRED_FOR_DRAW got scheduled.
-class LayerTreeHostTestReadyToDrawNonEmpty
-    : public LayerTreeHostTestReadyToDrawEmpty {
+class LayerTreeHostTestReadyToDrawNonEmpty : public LayerTreeHostTest {
  public:
+  LayerTreeHostTestReadyToDrawNonEmpty()
+      : did_notify_ready_to_draw_(false),
+        all_tiles_required_for_draw_are_ready_to_draw_(false) {}
+
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void NotifyReadyToDrawOnThread(LayerTreeHostImpl* impl) override {
+    did_notify_ready_to_draw_ = true;
+    all_tiles_required_for_draw_are_ready_to_draw_ =
+        impl->tile_manager()->IsReadyToDraw();
+    EndTest();
+  }
+
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
     EXPECT_TRUE(all_tiles_required_for_draw_are_ready_to_draw_);
-    EXPECT_LE(size_t(1), required_for_draw_count_);
   }
 
  private:
   FakeContentLayerClient client_;
+  bool did_notify_ready_to_draw_;
+  bool all_tiles_required_for_draw_are_ready_to_draw_;
 };
 
 // Note: With this test setup, we only get tiles flagged as REQUIRED_FOR_DRAW in
 // single threaded mode.
 SINGLE_THREAD_IMPL_TEST_F(LayerTreeHostTestReadyToDrawNonEmpty);
 
 // Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
 // draw with frame 0.
 class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
  public:
@@ skipping 5631 matching lines @@
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(4u, host_impl->resource_provider()->num_resources());
 
     // Verify which tiles got resources using an eviction iterator, which has to
     // return all tiles that have resources.
     scoped_ptr<EvictionTilePriorityQueue> eviction_queue(
-        host_impl->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+        host_impl->tile_manager()->BuildEvictionQueue());
     int tile_count = 0;
     for (; !eviction_queue->IsEmpty(); eviction_queue->Pop()) {
       Tile* tile = eviction_queue->Top();
       // Ensure this tile is within the viewport.
       EXPECT_TRUE(tile->content_rect().Intersects(gfx::Rect(viewport_size_)));
       // Ensure that the tile is 1/4 of the viewport tall (plus padding).
       EXPECT_EQ(tile->content_rect().height(),
                 (viewport_size_.height() / 4) + 2);
       ++tile_count;
     }
@@ skipping 388 matching lines @@
 
   void AfterTest() override { EXPECT_TRUE(did_commit_); }
 
  private:
   bool did_commit_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoTasksBetweenWillAndDidCommit);
 
 }  // namespace cc