Remove the concept of OutputSurface from ResourceProvider.

cc/raster/raster_buffer_provider_perftest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 169 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl);
 };
 
 class RasterBufferProviderPerfTestBase {
  public:
   typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
   RasterBufferProviderPerfTestBase()
-      : context_provider_(make_scoped_refptr(new PerfContextProvider)),
+      : compositor_context_provider_(
+            make_scoped_refptr(new PerfContextProvider)),
+        worker_context_provider_(make_scoped_refptr(new PerfContextProvider)),
         task_runner_(new base::TestSimpleTaskRunner),
         task_graph_runner_(new SynchronousTaskGraphRunner),
         timer_(kWarmupRuns,
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                kTimeCheckInterval) {}
 
   void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
                               TileTask::Vector* image_decode_tasks) {
     for (unsigned i = 0; i < num_image_decode_tasks; ++i)
       image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
@@ skipping 40 matching lines @@
             TaskGraph::Edge(decode_task.get(), raster_task.get()));
       }
 
       graph->nodes.push_back(TaskGraph::Node(
           raster_task.get(), 0u /* group */, priority,
           static_cast<uint32_t>(raster_task->dependencies().size())));
     }
   }
 
  protected:
-  scoped_refptr<ContextProvider> context_provider_;
+  scoped_refptr<ContextProvider> compositor_context_provider_;
+  scoped_refptr<ContextProvider> worker_context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   std::unique_ptr<SynchronousTaskGraphRunner> task_graph_runner_;
   LapTimer timer_;
 };
 
 class RasterBufferProviderPerfTest
     : public RasterBufferProviderPerfTestBase,
       public testing::TestWithParam<RasterBufferProviderType> {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
     std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
     switch (GetParam()) {
       case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
             resource_provider_.get(), PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         Create3dOutputSurfaceAndResourceProvider();
-        raster_buffer_provider = OneCopyRasterBufferProvider::Create(
-            task_runner_.get(), context_provider_.get(),
-            resource_provider_.get(), std::numeric_limits<int>::max(), false,
+        raster_buffer_provider = base::MakeUnique<OneCopyRasterBufferProvider>(
+            task_runner_.get(), compositor_context_provider_.get(),
+            worker_context_provider_.get(), resource_provider_.get(),
+            std::numeric_limits<int>::max(), false,
             std::numeric_limits<int>::max(),
             PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
-        raster_buffer_provider = GpuRasterBufferProvider::Create(
-            context_provider_.get(), resource_provider_.get(), false, 0);
+        raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
+            compositor_context_provider_.get(), worker_context_provider_.get(),
+            resource_provider_.get(), false, 0);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
         raster_buffer_provider =
             BitmapRasterBufferProvider::Create(resource_provider_.get());
         break;
     }
 
     DCHECK(raster_buffer_provider);
 
@@ skipping 95 matching lines @@
     TaskGraph empty;
     tile_task_manager_->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
 
     perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(),
                            test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
  private:
   void Create3dOutputSurfaceAndResourceProvider() {
-    output_surface_ = FakeOutputSurface::Create3d(context_provider_);
+    output_surface_ = FakeOutputSurface::Create3d(compositor_context_provider_,
+                                                  worker_context_provider_);
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), nullptr, &gpu_memory_buffer_manager_);
   }
 
   void CreateSoftwareOutputSurfaceAndResourceProvider() {
     output_surface_ = FakeOutputSurface::CreateSoftware(
         base::WrapUnique(new SoftwareOutputDevice));
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ = FakeResourceProvider::Create(
@@ skipping 53 matching lines @@
                                           RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
                                           RASTER_BUFFER_PROVIDER_TYPE_GPU,
                                           RASTER_BUFFER_PROVIDER_TYPE_BITMAP));
 
 class RasterBufferProviderCommonPerfTest
     : public RasterBufferProviderPerfTestBase,
       public testing::Test {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
-    output_surface_ = FakeOutputSurface::Create3d(context_provider_);
+    output_surface_ = FakeOutputSurface::Create3d(compositor_context_provider_,
+                                                  worker_context_provider_);
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
   }
 
   void RunBuildTileTaskGraphTest(const std::string& test_name,
                                  unsigned num_raster_tasks,
                                  unsigned num_image_decode_tasks) {
     TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
@@ skipping 19 matching lines @@
   RunBuildTileTaskGraphTest("1_0", 1, 0);
   RunBuildTileTaskGraphTest("32_0", 32, 0);
   RunBuildTileTaskGraphTest("1_1", 1, 1);
   RunBuildTileTaskGraphTest("32_1", 32, 1);
   RunBuildTileTaskGraphTest("1_4", 1, 4);
   RunBuildTileTaskGraphTest("32_4", 32, 4);
 }
 
 }  // namespace
 }  // namespace cc