Fork cc::OutputSurface into cc::CompositorFrameSink.

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"
 #include "base/time/time.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/output/context_cache_controller.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/bitmap_raster_buffer_provider.h"
 #include "cc/raster/gpu_raster_buffer_provider.h"
 #include "cc/raster/one_copy_raster_buffer_provider.h"
 #include "cc/raster/raster_buffer_provider.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/raster/zero_copy_raster_buffer_provider.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
-#include "cc/test/fake_output_surface.h"
-#include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_resource_provider.h"
+#include "cc/test/test_context_provider.h"
 #include "cc/test/test_context_support.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/tiles/tile_task_manager.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ skipping 265 matching lines @@
 
       graph->nodes.push_back(TaskGraph::Node(
           raster_task.get(), 0u /* group */, priority,
           static_cast<uint32_t>(raster_task->dependencies().size())));
     }
   }
 
  protected:
   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 PerfRasterBufferProviderHelper,
       public testing::TestWithParam<RasterBufferProviderType> {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
     switch (GetParam()) {
       case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
-        Create3dOutputSurfaceAndResourceProvider();
+        Create3dResourceProvider();
         raster_buffer_provider_ = ZeroCopyRasterBufferProvider::Create(
             resource_provider_.get(), PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
-        Create3dOutputSurfaceAndResourceProvider();
+        Create3dResourceProvider();
         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(),
             false);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
-        Create3dOutputSurfaceAndResourceProvider();
+        Create3dResourceProvider();
         raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
             compositor_context_provider_.get(), worker_context_provider_.get(),
             resource_provider_.get(), false, 0, false);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
-        CreateSoftwareOutputSurfaceAndResourceProvider();
+        CreateSoftwareResourceProvider();
         raster_buffer_provider_ =
             BitmapRasterBufferProvider::Create(resource_provider_.get());
         break;
     }
 
     DCHECK(raster_buffer_provider_);
 
     tile_task_manager_ = TileTaskManagerImpl::Create(task_graph_runner_.get());
   }
   void TearDown() override {
@@ skipping 117 matching lines @@
     TaskGraph empty;
     raster_buffer_provider_->OrderingBarrier();
     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(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 Create3dResourceProvider() {
+    resource_provider_ =
+        FakeResourceProvider::Create(compositor_context_provider_.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(
-        output_surface_.get(), &shared_bitmap_manager_, nullptr);
+  void CreateSoftwareResourceProvider() {
+    resource_provider_ =
+        FakeResourceProvider::Create(nullptr, &shared_bitmap_manager_, nullptr);
   }
 
   std::string TestModifierString() const {
     switch (GetParam()) {
       case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
         return std::string("_zero_copy_raster_buffer_provider");
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         return std::string("_one_copy_raster_buffer_provider");
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         return std::string("_gpu_raster_buffer_provider");
@@ skipping 43 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(compositor_context_provider_,
-                                                  worker_context_provider_);
-    CHECK(output_surface_->BindToClient(&output_surface_client_));
-    resource_provider_ =
-        FakeResourceProvider::Create(output_surface_.get(), nullptr);
+    resource_provider_ = FakeResourceProvider::Create(
+        compositor_context_provider_.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;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(nullptr, num_raster_tasks, image_decode_tasks,
                       &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