cc: Move UI Resource management out of LayerTreeHost.

cc/layers/scrollbar_layer_unittest.cc

 // Copyright 2012 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 <stddef.h>
 
 #include <unordered_map>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
 #include "cc/input/scrollbar_animation_controller.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
 #include "cc/layers/solid_color_scrollbar_layer.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/quads/solid_color_draw_quad.h"
+#include "cc/resources/ui_resource_manager.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_scrollbar.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/mock_occlusion_tracker.h"
 #include "cc/test/stub_layer_tree_host_single_thread_client.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
-class FakeResourceTrackingLayerTreeHost : public FakeLayerTreeHost {
+class FakeResourceTrackingUIResourceManager : public UIResourceManager {
  public:
-  FakeResourceTrackingLayerTreeHost(FakeLayerTreeHostClient* client,
-                                    LayerTreeHost::InitParams* params)
-      : FakeLayerTreeHost(client, params, CompositorMode::SINGLE_THREADED),
-        next_id_(1),
+  FakeResourceTrackingUIResourceManager()
+      : next_id_(1),
         total_ui_resource_created_(0),
-        total_ui_resource_deleted_(0) {
-    InitializeSingleThreaded(&single_thread_client_,
-                             base::ThreadTaskRunnerHandle::Get(), nullptr);
-  }
+        total_ui_resource_deleted_(0) {}
+  ~FakeResourceTrackingUIResourceManager() override = default;
 
   UIResourceId CreateUIResource(UIResourceClient* content) override {
     total_ui_resource_created_++;
     UIResourceId nid = next_id_++;
     ui_resource_bitmap_map_.insert(
         std::make_pair(nid, content->GetBitmap(nid, false)));
     return nid;
   }
 
   // Deletes a UI resource.  May safely be called more than once.
@@ skipping 47 matching lines @@
 
     scrollbar_layer_id_ = -1;
 
     LayerTreeHost::InitParams params;
     params.client = &fake_client_;
     params.settings = &layer_tree_settings_;
     params.task_graph_runner = &task_graph_runner_;
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
 
-    layer_tree_host_.reset(
-        new FakeResourceTrackingLayerTreeHost(&fake_client_, &params));
+    std::unique_ptr<FakeResourceTrackingUIResourceManager>
+        fake_ui_resource_manager =
+            base::MakeUnique<FakeResourceTrackingUIResourceManager>();
+    fake_ui_resource_manager_ = fake_ui_resource_manager.get();
+
+    layer_tree_host_.reset(new FakeLayerTreeHost(
+        &fake_client_, &params, CompositorMode::SINGLE_THREADED));
+    layer_tree_host_->SetUIResourceManagerForTesting(
+        std::move(fake_ui_resource_manager));
+    layer_tree_host_->InitializeSingleThreaded(
+        &single_thread_client_, base::ThreadTaskRunnerHandle::Get(), nullptr);
     layer_tree_ = layer_tree_host_->GetLayerTree();
     layer_tree_host_->SetVisible(true);
     fake_client_.SetLayerTreeHost(layer_tree_host_.get());
   }
 
   LayerImpl* LayerImplForScrollAreaAndScrollbar(
       FakeLayerTreeHost* host,
       std::unique_ptr<Scrollbar> scrollbar,
       bool reverse_order,
       bool use_solid_color_scrollbar,
@@ skipping 13 matching lines @@
     }
     layer_tree_root->AddChild(child1);
     layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
     scrollbar_layer_id_ = reverse_order ? child1->id() : child2->id();
     host->SetRootLayer(layer_tree_root);
     host->BuildPropertyTreesForTesting();
     return host->CommitAndCreateLayerImplTree();
   }
 
  protected:
+  FakeResourceTrackingUIResourceManager* fake_ui_resource_manager_;
   FakeLayerTreeHostClient fake_client_;
+  StubLayerTreeHostSingleThreadClient single_thread_client_;
   TestTaskGraphRunner task_graph_runner_;
   LayerTreeSettings layer_tree_settings_;
-  std::unique_ptr<FakeResourceTrackingLayerTreeHost> layer_tree_host_;
+  std::unique_ptr<FakeLayerTreeHost> layer_tree_host_;
   LayerTree* layer_tree_;
   int scrollbar_layer_id_;
 };
 
 TEST_F(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
   // Create and attach a non-overlay scrollbar.
   std::unique_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       layer_tree_host_.get(), std::move(scrollbar), false, false, 0, 0);
   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
@@ skipping 601 matching lines @@
     scrollbar_layer->set_visible_layer_rect(gfx::Rect(0, 0, 100, 200));
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 
     scrollbar_layer->SavePaintProperties();
     for (int update_counter = 0; update_counter < num_updates; update_counter++)
       scrollbar_layer->Update();
 
     // A non-solid-color scrollbar should have requested two textures.
-    EXPECT_EQ(expected_resources, layer_tree_host_->UIResourceCount());
-    EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-    EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+    EXPECT_EQ(expected_resources, fake_ui_resource_manager_->UIResourceCount());
+    EXPECT_EQ(expected_created,
+              fake_ui_resource_manager_->TotalUIResourceCreated());
+    EXPECT_EQ(expected_deleted,
+              fake_ui_resource_manager_->TotalUIResourceDeleted());
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   }
 };
 
 TEST_F(ScrollbarLayerTestResourceCreationAndRelease, ResourceUpload) {
   bool use_solid_color_scrollbars = false;
   TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
   int num_updates[3] = {1, 5, 10};
   int created = 0;
@@ skipping 38 matching lines @@
   size_t resource_count;
   int expected_created, expected_deleted;
   scrollbar_layer->SavePaintProperties();
 
   resource_count = 2;
   expected_created = 2;
   expected_deleted = 0;
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 0;
   expected_created = 2;
   expected_deleted = 2;
   scrollbar_layer->SetBounds(gfx::Size(0, 0));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_EQ(0, scrollbar_layer->track_resource_id());
   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 0;
   expected_created = 2;
   expected_deleted = 2;
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
   EXPECT_FALSE(scrollbar_layer->Update());
   EXPECT_EQ(0, scrollbar_layer->track_resource_id());
   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 2;
   expected_created = 4;
   expected_deleted = 2;
   scrollbar_layer->SetBounds(gfx::Size(100, 15));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 1;
   expected_created = 5;
   expected_deleted = 4;
   scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 0;
   expected_created = 5;
   expected_deleted = 5;
   scrollbar_layer->SetBounds(gfx::Size(0, 0));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_EQ(0, scrollbar_layer->track_resource_id());
   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 2;
   expected_created = 7;
   expected_deleted = 5;
   scrollbar_layer->SetBounds(gfx::Size(100, 15));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   scrollbar_layer->fake_scrollbar()->set_has_thumb(true);
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
 
   resource_count = 2;
   expected_created = 9;
   expected_deleted = 7;
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
   EXPECT_TRUE(scrollbar_layer->Update());
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   resource_count = 1;
   expected_created = 10;
   expected_deleted = 9;
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
   scrollbar_layer->SetBounds(gfx::Size(90, 15));
   EXPECT_TRUE(scrollbar_layer->Update());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
-  EXPECT_EQ(
-      gfx::Size(90, 15),
-      layer_tree_host_->ui_resource_size(scrollbar_layer->track_resource_id()));
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
+  EXPECT_EQ(gfx::Size(90, 15), fake_ui_resource_manager_->ui_resource_size(
+                                   scrollbar_layer->track_resource_id()));
 
   scrollbar_layer->ResetNeedsDisplayForTesting();
   EXPECT_FALSE(scrollbar_layer->Update());
   EXPECT_NE(0, scrollbar_layer->track_resource_id());
   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
-  EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
-  EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-  EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+  EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+  EXPECT_EQ(expected_created,
+            fake_ui_resource_manager_->TotalUIResourceCreated());
+  EXPECT_EQ(expected_deleted,
+            fake_ui_resource_manager_->TotalUIResourceDeleted());
 
   testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class ScaledScrollbarLayerTestResourceCreation : public ScrollbarLayerTest {
  public:
   void TestResourceUpload(const float test_scale) {
     gfx::Point scrollbar_location(0, 185);
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
@@ skipping 16 matching lines @@
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 
     layer_tree_->SetDeviceScaleFactor(test_scale);
 
     scrollbar_layer->SavePaintProperties();
     scrollbar_layer->Update();
 
     // Verify that we have not generated any content uploads that are larger
     // than their destination textures.
 
-    gfx::Size track_size = layer_tree_host_->ui_resource_size(
+    gfx::Size track_size = fake_ui_resource_manager_->ui_resource_size(
         scrollbar_layer->track_resource_id());
-    gfx::Size thumb_size = layer_tree_host_->ui_resource_size(
+    gfx::Size thumb_size = fake_ui_resource_manager_->ui_resource_size(
         scrollbar_layer->thumb_resource_id());
 
     EXPECT_LE(track_size.width(),
               scrollbar_layer->internal_content_bounds().width());
     EXPECT_LE(track_size.height(),
               scrollbar_layer->internal_content_bounds().height());
     EXPECT_LE(thumb_size.width(),
               scrollbar_layer->internal_content_bounds().width());
     EXPECT_LE(thumb_size.height(),
               scrollbar_layer->internal_content_bounds().height());
@@ skipping 40 matching lines @@
     scrollbar_layer->fake_scrollbar()->set_track_rect(scrollbar_rect);
     scrollbar_layer->set_visible_layer_rect(scrollbar_rect);
 
     layer_tree_->SetDeviceScaleFactor(test_scale);
 
     gfx::Rect screen_space_clip_rect;
     scrollbar_layer->SavePaintProperties();
 
     scrollbar_layer->Update();
 
-    UIResourceBitmap* bitmap = layer_tree_host_->ui_resource_bitmap(
+    UIResourceBitmap* bitmap = fake_ui_resource_manager_->ui_resource_bitmap(
         scrollbar_layer->track_resource_id());
 
     DCHECK(bitmap);
 
     AutoLockUIResourceBitmap locked_bitmap(*bitmap);
 
     const SkColor* pixels =
         reinterpret_cast<const SkColor*>(locked_bitmap.GetPixels());
     SkColor color = argb_to_skia(
         scrollbar_layer->fake_scrollbar()->paint_fill_color());
@@ skipping 31 matching lines @@
   TestScale(gfx::Rect(1240, 0, 15, 1333), 2.7754839f);
   TestScale(gfx::Rect(1240, 0, 15, 677), 2.46677136f);
 
   // Horizontal Scrollbars.
   TestScale(gfx::Rect(0, 1240, 1333, 15), 2.7754839f);
   TestScale(gfx::Rect(0, 1240, 677, 15), 2.46677136f);
 }
 
 }  // namespace
 }  // namespace cc