(reland) cc: Refactor layer/tile manager unittest to extract common code.

cc/test/test_layer_tree_host_base.cc

+// Copyright 2016 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/test/test_layer_tree_host_base.h"
+
+#include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_raster_source.h"
+#include "cc/trees/layer_tree_impl.h"
+
+namespace cc {
+
+TestLayerTreeHostBase::TestLayerTreeHostBase()
+    : task_runner_provider_(base::ThreadTaskRunnerHandle::Get()),
+      pending_layer_(nullptr),
+      active_layer_(nullptr),
+      old_pending_layer_(nullptr),
+      root_id_(6),
+      id_(7) {}
+
+TestLayerTreeHostBase::~TestLayerTreeHostBase() = default;
+
+void TestLayerTreeHostBase::SetUp() {
+  output_surface_ = CreateOutputSurface();
+  task_graph_runner_ = CreateTaskGraphRunner();
+  host_impl_ = CreateHostImpl(CreateSettings(), &task_runner_provider_,
+                              &shared_bitmap_manager_, task_graph_runner_.get(),
+                              &gpu_memory_buffer_manager_);
+  InitializeRenderer();
+  SetInitialTreePriority();
+}
+
+LayerTreeSettings TestLayerTreeHostBase::CreateSettings() {
+  return LayerTreeSettings();
+}
+
+std::unique_ptr<OutputSurface> TestLayerTreeHostBase::CreateOutputSurface() {
+  return FakeOutputSurface::Create3d();
+}
+
+std::unique_ptr<FakeLayerTreeHostImpl> TestLayerTreeHostBase::CreateHostImpl(
+    const LayerTreeSettings& settings,
+    TaskRunnerProvider* task_runner_provider,
+    SharedBitmapManager* shared_bitmap_manager,
+    TaskGraphRunner* task_graph_runner,
+    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
+  return base::WrapUnique(new FakeLayerTreeHostImpl(
+      settings, task_runner_provider, shared_bitmap_manager, task_graph_runner,
+      gpu_memory_buffer_manager));
+}
+
+std::unique_ptr<TaskGraphRunner>
+TestLayerTreeHostBase::CreateTaskGraphRunner() {
+  return base::WrapUnique(new TestTaskGraphRunner);
+}
+
+void TestLayerTreeHostBase::InitializeRenderer() {
+  host_impl_->SetVisible(true);
+  host_impl_->InitializeRenderer(output_surface_.get());
+}
+
+void TestLayerTreeHostBase::ResetOutputSurface(
+    std::unique_ptr<OutputSurface> output_surface) {
+  host_impl()->DidLoseOutputSurface();
+  host_impl()->SetVisible(true);
+  host_impl()->InitializeRenderer(output_surface.get());
+  output_surface_ = std::move(output_surface);
+}
+
+std::unique_ptr<FakeLayerTreeHostImpl> TestLayerTreeHostBase::TakeHostImpl() {
+  return std::move(host_impl_);
+}
+
+void TestLayerTreeHostBase::SetupDefaultTrees(const gfx::Size& layer_bounds) {
+  scoped_refptr<FakeRasterSource> pending_raster_source =
+      FakeRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeRasterSource> active_raster_source =
+      FakeRasterSource::CreateFilled(layer_bounds);
+
+  SetupTrees(std::move(pending_raster_source), std::move(active_raster_source));
+}
+
+void TestLayerTreeHostBase::SetupTrees(
+    scoped_refptr<RasterSource> pending_raster_source,
+    scoped_refptr<RasterSource> active_raster_source) {
+  SetupPendingTree(std::move(active_raster_source));
+  ActivateTree();
+  SetupPendingTree(std::move(pending_raster_source));
+}
+
+void TestLayerTreeHostBase::SetupPendingTree(
+    scoped_refptr<RasterSource> raster_source) {
+  SetupPendingTree(std::move(raster_source), gfx::Size(), Region());
+}
+
+void TestLayerTreeHostBase::SetupPendingTree(
+    scoped_refptr<RasterSource> raster_source,
+    const gfx::Size& tile_size,
+    const Region& invalidation) {
+  host_impl()->CreatePendingTree();
+  host_impl()->pending_tree()->PushPageScaleFromMainThread(1.f, 0.00001f,
+                                                           100000.f);
+  LayerTreeImpl* pending_tree = host_impl()->pending_tree();
+  pending_tree->SetDeviceScaleFactor(
+      host_impl()->active_tree()->device_scale_factor());
+
+  // Steal from the recycled tree if possible.
+  LayerImpl* pending_root = pending_tree->root_layer();
+  std::unique_ptr<FakePictureLayerImpl> pending_layer;
+  DCHECK(!pending_root || pending_root->id() == root_id_);
+  if (!pending_root) {
+    std::unique_ptr<LayerImpl> new_pending_root =
+        LayerImpl::Create(pending_tree, root_id_);
+    pending_layer = FakePictureLayerImpl::Create(pending_tree, id_);
+    if (!tile_size.IsEmpty())
+      pending_layer->set_fixed_tile_size(tile_size);
+    pending_layer->SetDrawsContent(true);
+    pending_layer->SetScrollClipLayer(new_pending_root->id());
+    pending_root = new_pending_root.get();
+    pending_tree->SetRootLayer(std::move(new_pending_root));
+  } else {
+    pending_layer.reset(static_cast<FakePictureLayerImpl*>(
+        pending_root->RemoveChildForTesting(pending_root->children()[0])
+            .release()));
+    if (!tile_size.IsEmpty())
+      pending_layer->set_fixed_tile_size(tile_size);
+  }
+  pending_root->test_properties()->force_render_surface = true;
+  // The bounds() just mirror the raster source size.
+  pending_layer->SetBounds(raster_source->GetSize());
+  pending_layer->SetRasterSourceOnPending(raster_source, invalidation);
+
+  pending_root->AddChild(std::move(pending_layer));
+  pending_tree->SetViewportLayersFromIds(Layer::INVALID_ID,
+                                         pending_tree->root_layer()->id(),
+                                         Layer::INVALID_ID, Layer::INVALID_ID);
+
+  pending_layer_ = static_cast<FakePictureLayerImpl*>(
+      host_impl()->pending_tree()->LayerById(id_));
+
+  // Add tilings/tiles for the layer.
+  bool update_lcd_text = false;
+  RebuildPropertyTreesOnPendingTree();
+  host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+}
+
+void TestLayerTreeHostBase::ActivateTree() {
+  RebuildPropertyTreesOnPendingTree();
+  host_impl()->ActivateSyncTree();
+  CHECK(!host_impl()->pending_tree());
+  CHECK(host_impl()->recycle_tree());
+  old_pending_layer_ = pending_layer_;
+  pending_layer_ = nullptr;
+  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 TestLayerTreeHostBase::RebuildPropertyTreesOnPendingTree() {
+  host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
+  host_impl()->pending_tree()->BuildPropertyTreesForTesting();
+}
+
+void TestLayerTreeHostBase::SetInitialTreePriority() {
+  GlobalStateThatImpactsTilePriority state;
+
+  state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
+  state.num_resources_limit = 10000;
+  state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
+  state.memory_limit_policy = ALLOW_ANYTHING;
+  state.tree_priority = SAME_PRIORITY_FOR_BOTH_TREES;
+
+  host_impl_->resource_pool()->SetResourceUsageLimits(
+      state.soft_memory_limit_in_bytes, state.num_resources_limit);
+  host_impl_->tile_manager()->SetGlobalStateForTesting(state);
+}
+
+}  // namespace cc