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

cc/test/test_layer_tree_host_base.h

+// 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.
+
+#ifndef CC_TEST_TEST_LAYER_TREE_HOST_BASE_H_
+#define CC_TEST_TEST_LAYER_TREE_HOST_BASE_H_
+
+#include <memory>
+
+#include "cc/output/output_surface.h"
+#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_host_impl.h"
+#include "cc/test/fake_picture_layer_impl.h"
+#include "cc/test/test_gpu_memory_buffer_manager.h"
+#include "cc/test/test_shared_bitmap_manager.h"
+#include "cc/test/test_task_graph_runner.h"
+#include "cc/tiles/tile_priority.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace cc {
+
+class TestLayerTreeHostBase : public testing::Test {
+ protected:
+  TestLayerTreeHostBase();
+  ~TestLayerTreeHostBase() override;
+
+  void SetUp() override;
+
+  virtual LayerTreeSettings CreateSettings();
+  virtual std::unique_ptr<OutputSurface> CreateOutputSurface();
+  virtual std::unique_ptr<FakeLayerTreeHostImpl> CreateHostImpl(
+      const LayerTreeSettings& settings,
+      TaskRunnerProvider* task_runner_provider,
+      SharedBitmapManager* shared_bitmap_manager,
+      TaskGraphRunner* task_graph_runner,
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_);
+  virtual std::unique_ptr<TaskGraphRunner> CreateTaskGraphRunner();
+  virtual void InitializeRenderer();
+
+  void ResetOutputSurface(std::unique_ptr<OutputSurface> output_surface);
+  std::unique_ptr<FakeLayerTreeHostImpl> TakeHostImpl();
+
+  void SetupDefaultTrees(const gfx::Size& layer_bounds);
+  void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+                  scoped_refptr<RasterSource> active_raster_source);
+  void SetupPendingTree(scoped_refptr<RasterSource> raster_source);
+  void SetupPendingTree(scoped_refptr<RasterSource> raster_source,
+                        const gfx::Size& tile_size,
+                        const Region& invalidation);
+  void ActivateTree();
+  void RebuildPropertyTreesOnPendingTree();
+
+  FakeLayerTreeHostImpl* host_impl() const { return host_impl_.get(); }
+  TaskGraphRunner* task_graph_runner() const {
+    return task_graph_runner_.get();
+  }
+  OutputSurface* output_surface() const { return output_surface_.get(); }
+  FakePictureLayerImpl* pending_layer() const { return pending_layer_; }
+  FakePictureLayerImpl* active_layer() const { return active_layer_; }
+  FakePictureLayerImpl* old_pending_layer() const { return old_pending_layer_; }
+  int layer_id() const { return id_; }
+
+ private:
+  void SetInitialTreePriority();
+
+  FakeImplTaskRunnerProvider task_runner_provider_;
+  TestSharedBitmapManager shared_bitmap_manager_;
+  std::unique_ptr<TaskGraphRunner> task_graph_runner_;
+  TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
+  std::unique_ptr<OutputSurface> output_surface_;
+  std::unique_ptr<FakeLayerTreeHostImpl> host_impl_;
+
+  FakePictureLayerImpl* pending_layer_;
+  FakePictureLayerImpl* active_layer_;
+  FakePictureLayerImpl* old_pending_layer_;
+  const int root_id_;
+  const int id_;
+};
+
+}  // namespace cc
+
+#endif  // CC_TEST_TEST_LAYER_TREE_HOST_BASE_H_