Fork cc::OutputSurface into cc::CompositorFrameSink.

android_webview/browser/browser_view_renderer_unittest.cc

Index: android_webview/browser/browser_view_renderer_unittest.cc
diff --git a/android_webview/browser/browser_view_renderer_unittest.cc b/android_webview/browser/browser_view_renderer_unittest.cc
index 3f8693856be89d5283cbebd950c860d2cd6dbaf5..bd7865d60a13f8113be4eacf339fc5a608885173 100644
--- a/android_webview/browser/browser_view_renderer_unittest.cc
+++ b/android_webview/browser/browser_view_renderer_unittest.cc
@@ -293,7 +293,8 @@ RENDERING_TEST_F(CompositorNoFrameTest);
 class ResourceRenderingTest : public RenderingTest {
  public:
   using ResourceCountMap = std::map<cc::ResourceId, int>;
-  using OutputSurfaceResourceCountMap = std::map<uint32_t, ResourceCountMap>;
+  using CompositorFrameSinkResourceCountMap =
+      std::map<uint32_t, ResourceCountMap>;
 
   virtual std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
       int frame_number) = 0;
@@ -305,7 +306,7 @@ class ResourceRenderingTest : public RenderingTest {
 
   void WillOnDraw() override {
     if (next_frame_) {
-      compositor_->SetHardwareFrame(next_frame_->output_surface_id,
+      compositor_->SetHardwareFrame(next_frame_->compositor_frame_sink_id,
                                     std::move(next_frame_->frame));
     }
   }
@@ -319,13 +320,13 @@ class ResourceRenderingTest : public RenderingTest {
     }
   }
 
-  OutputSurfaceResourceCountMap GetReturnedResourceCounts() {
-    OutputSurfaceResourceCountMap counts;
+  CompositorFrameSinkResourceCountMap GetReturnedResourceCounts() {
+    CompositorFrameSinkResourceCountMap counts;
     content::TestSynchronousCompositor::FrameAckArray returned_resources_array;
     compositor_->SwapReturnedResources(&returned_resources_array);
     for (const auto& resources : returned_resources_array) {
       for (const auto& returned_resource : resources.resources) {
-        counts[resources.output_surface_id][returned_resource.id] +=
+        counts[resources.compositor_frame_sink_id][returned_resource.id] +=
             returned_resource.count;
       }
     }
@@ -348,9 +349,9 @@ class ResourceRenderingTest : public RenderingTest {
   int frame_number_;
 };
 
-class SwitchOutputSurfaceIdTest : public ResourceRenderingTest {
+class SwitchCompositorFrameSinkIdTest : public ResourceRenderingTest {
   struct FrameInfo {
-    uint32_t output_surface_id;
+    uint32_t compositor_frame_sink_id;
     cc::ResourceId resource_id;  // Each frame contains a single resource.
   };
 
@@ -368,19 +369,22 @@ class SwitchOutputSurfaceIdTest : public ResourceRenderingTest {
 
     std::unique_ptr<content::SynchronousCompositor::Frame> frame(
         new content::SynchronousCompositor::Frame);
-    frame->output_surface_id = infos[frame_number].output_surface_id;
+    frame->compositor_frame_sink_id =
+        infos[frame_number].compositor_frame_sink_id;
     frame->frame = ConstructFrame(infos[frame_number].resource_id);
 
-    if (last_output_surface_id_ != infos[frame_number].output_surface_id) {
+    if (last_compositor_frame_sink_id_ !=
+        infos[frame_number].compositor_frame_sink_id) {
       expected_return_count_.clear();
-      last_output_surface_id_ = infos[frame_number].output_surface_id;
+      last_compositor_frame_sink_id_ =
+          infos[frame_number].compositor_frame_sink_id;
     }
     ++expected_return_count_[infos[frame_number].resource_id];
     return frame;
   }
 
   void StartTest() override {
-    last_output_surface_id_ = -1U;
+    last_compositor_frame_sink_id_ = -1U;
     ResourceRenderingTest::StartTest();
   }
 
@@ -391,16 +395,16 @@ class SwitchOutputSurfaceIdTest : public ResourceRenderingTest {
 
     // Make sure resources for the last output surface are returned.
     EXPECT_EQ(expected_return_count_,
-              GetReturnedResourceCounts()[last_output_surface_id_]);
+              GetReturnedResourceCounts()[last_compositor_frame_sink_id_]);
     EndTest();
   }
 
  private:
-  uint32_t last_output_surface_id_;
+  uint32_t last_compositor_frame_sink_id_;
   ResourceCountMap expected_return_count_;
 };
 
-RENDERING_TEST_F(SwitchOutputSurfaceIdTest);
+RENDERING_TEST_F(SwitchCompositorFrameSinkIdTest);
 
 class RenderThreadManagerDeletionTest : public ResourceRenderingTest {
   std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
@@ -409,20 +413,20 @@ class RenderThreadManagerDeletionTest : public ResourceRenderingTest {
       return nullptr;
     }
 
-    const uint32_t output_surface_id = 0u;
+    const uint32_t compositor_frame_sink_id = 0u;
     const cc::ResourceId resource_id =
         static_cast<cc::ResourceId>(frame_number);
 
     std::unique_ptr<content::SynchronousCompositor::Frame> frame(
         new content::SynchronousCompositor::Frame);
-    frame->output_surface_id = output_surface_id;
+    frame->compositor_frame_sink_id = compositor_frame_sink_id;
     frame->frame = ConstructFrame(resource_id);
-    ++expected_return_count_[output_surface_id][resource_id];
+    ++expected_return_count_[compositor_frame_sink_id][resource_id];
     return frame;
   }
 
   void CheckResults() override {
-    OutputSurfaceResourceCountMap resource_counts;
+    CompositorFrameSinkResourceCountMap resource_counts;
     functor_.reset();
     // Make sure resources for the last frame are returned.
     EXPECT_EQ(expected_return_count_, GetReturnedResourceCounts());
@@ -430,7 +434,7 @@ class RenderThreadManagerDeletionTest : public ResourceRenderingTest {
   }
 
  private:
-  OutputSurfaceResourceCountMap expected_return_count_;
+  CompositorFrameSinkResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(RenderThreadManagerDeletionTest);
@@ -471,20 +475,20 @@ class RenderThreadManagerSwitchTest : public ResourceRenderingTest {
         return nullptr;
     }
 
-    const uint32_t output_surface_id = 0u;
+    const uint32_t compositor_frame_sink_id = 0u;
     const cc::ResourceId resource_id =
         static_cast<cc::ResourceId>(frame_number);
 
     std::unique_ptr<content::SynchronousCompositor::Frame> frame(
         new content::SynchronousCompositor::Frame);
-    frame->output_surface_id = output_surface_id;
+    frame->compositor_frame_sink_id = compositor_frame_sink_id;
     frame->frame = ConstructFrame(resource_id);
-    ++expected_return_count_[output_surface_id][resource_id];
+    ++expected_return_count_[compositor_frame_sink_id][resource_id];
     return frame;
   }
 
   void CheckResults() override {
-    OutputSurfaceResourceCountMap resource_counts;
+    CompositorFrameSinkResourceCountMap resource_counts;
     functor_.reset();
     // Make sure resources for all frames are returned.
     EXPECT_EQ(expected_return_count_, GetReturnedResourceCounts());
@@ -493,7 +497,7 @@ class RenderThreadManagerSwitchTest : public ResourceRenderingTest {
 
  private:
   std::unique_ptr<FakeFunctor> saved_functor_;
-  OutputSurfaceResourceCountMap expected_return_count_;
+  CompositorFrameSinkResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(RenderThreadManagerSwitchTest);