Re-land: cc: Implement shared worker contexts.

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"
@@ skipping 28 matching lines @@
 };
 
 class TileManagerTilePriorityQueueTest : public testing::Test {
  public:
   TileManagerTilePriorityQueueTest()
       : memory_limit_policy_(ALLOW_ANYTHING),
         max_tiles_(10000),
         ready_to_activate_(false),
         id_(7),
         proxy_(base::ThreadTaskRunnerHandle::Get()),
+        output_surface_(FakeOutputSurface::Create3d()),
         host_impl_(LowResTilingsSettings(),
                    &proxy_,
                    &shared_bitmap_manager_,
                    &task_graph_runner_) {}
 
   void SetTreePriority(TreePriority tree_priority) {
     GlobalStateThatImpactsTilePriority state;
     gfx::Size tile_size(256, 256);
 
     state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
     state.num_resources_limit = max_tiles_;
     state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
     state.memory_limit_policy = memory_limit_policy_;
     state.tree_priority = tree_priority;
 
     global_state_ = state;
     host_impl_.resource_pool()->SetResourceUsageLimits(
         state.soft_memory_limit_in_bytes,
         state.num_resources_limit);
     host_impl_.tile_manager()->SetGlobalStateForTesting(state);
   }
 
   void SetUp() override {
     InitializeRenderer();
     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   }
 
   virtual void InitializeRenderer() {
-    host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
+    host_impl_.InitializeRenderer(output_surface_.get());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
     gfx::Size tile_size(100, 100);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
@@ skipping 61 matching lines @@
  protected:
   GlobalStateThatImpactsTilePriority global_state_;
 
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_tiles_;
   bool ready_to_activate_;
   int id_;
   FakeImplProxy proxy_;
+  scoped_ptr<OutputSurface> output_surface_;
   FakeLayerTreeHostImpl host_impl_;
   FakePictureLayerImpl* pending_layer_;
   FakePictureLayerImpl* active_layer_;
 };
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
@@ skipping 1247 matching lines @@
         intersecting_rect);     // Eventually rect.
     scoped_ptr<TilingSetRasterQueueAll> queue(
         new TilingSetRasterQueueAll(tiling_set.get(), false));
     EXPECT_FALSE(queue->IsEmpty());
   }
 }
 
 class TileManagerTest : public testing::Test {
  public:
   TileManagerTest()
-      : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_) {}
+      : output_surface_(FakeOutputSurface::CreateSoftware(
+            make_scoped_ptr(new SoftwareOutputDevice))),
+        host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_) {
+    host_impl_.InitializeRenderer(output_surface_.get());
+  }
 
  protected:
   // MockLayerTreeHostImpl allows us to intercept tile manager callbacks.
   class MockLayerTreeHostImpl : public FakeLayerTreeHostImpl {
    public:
     MockLayerTreeHostImpl(Proxy* proxy,
                           SharedBitmapManager* manager,
                           TaskGraphRunner* task_graph_runner)
-        : FakeLayerTreeHostImpl(proxy, manager, task_graph_runner) {
-      InitializeRenderer(FakeOutputSurface::CreateSoftware(
-          make_scoped_ptr(new SoftwareOutputDevice)));
-    }
+        : FakeLayerTreeHostImpl(proxy, manager, task_graph_runner) {}
 
     MOCK_METHOD0(NotifyAllTileTasksCompleted, void());
   };
 
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   FakeImplProxy proxy_;
+  scoped_ptr<OutputSurface> output_surface_;
   MockLayerTreeHostImpl host_impl_;
 };
 
 // Test to ensure that we call NotifyAllTileTasksCompleted when PrepareTiles is
 // called.
 TEST_F(TileManagerTest, AllWorkFinishedTest) {
   // Check with no tile work enqueued.
   {
     base::RunLoop run_loop;
     EXPECT_FALSE(host_impl_.tile_manager()->HasScheduledTileTasksForTesting());
@@ skipping 98 matching lines @@
           // background is not visible.
           ASSERT_EQ(SK_ColorBLUE, bitmap->getColor(x, y));
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace cc