Fork cc::OutputSurface into cc::CompositorFrameSink.

android_webview/browser/browser_view_renderer_unittest.cc

 // Copyright 2014 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 <map>
 #include <queue>
 #include <utility>
 
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
@@ skipping 275 matching lines @@
 
  private:
   int on_draw_count_;
 };
 
 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;
 
   void StartTest() override {
     frame_number_ = 0;
     AdvanceFrame();
   }
 
   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));
     }
   }
 
   void DidOnDraw(bool success) override {
     EXPECT_EQ(next_frame_ != nullptr, success);
     if (!AdvanceFrame()) {
       ui_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&ResourceRenderingTest::CheckResults,
                                            base::Unretained(this)));
     }
   }
 
-  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;
       }
     }
     return counts;
   }
 
   virtual void CheckResults() = 0;
 
  private:
   bool AdvanceFrame() {
     next_frame_ = GetFrame(frame_number_++);
     if (next_frame_) {
       browser_view_renderer_->PostInvalidate(ActiveCompositor());
       return true;
     }
     return false;
   }
 
   std::unique_ptr<content::SynchronousCompositor::Frame> next_frame_;
   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.
   };
 
   std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
       int frame_number) override {
     static const FrameInfo infos[] = {
         // First output surface.
         {0u, 1u}, {0u, 1u}, {0u, 2u}, {0u, 2u}, {0u, 3u}, {0u, 3u}, {0u, 4u},
         // Second output surface.
         {1u, 1u}, {1u, 1u}, {1u, 2u}, {1u, 2u}, {1u, 3u}, {1u, 3u}, {1u, 4u},
     };
     if (frame_number >= static_cast<int>(arraysize(infos))) {
       return nullptr;
     }
 
     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();
   }
 
   void CheckResults() override {
     GetCompositorFrameConsumer()->DeleteHardwareRendererOnUI();
     window_->Detach();
     window_.reset();
 
     // 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(
       int frame_number) override {
     if (frame_number > 0) {
       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());
     EndTest();
   }
 
  private:
-  OutputSurfaceResourceCountMap expected_return_count_;
+  CompositorFrameSinkResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(RenderThreadManagerDeletionTest);
 
 class RenderThreadManagerSwitchTest : public ResourceRenderingTest {
   std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
       int frame_number) override {
     switch (frame_number) {
       case 0: {
         // Draw a frame with initial RTM.
@@ skipping 20 matching lines @@
         // Switch back to the initial RTM, allowing the new RTM to be destroyed.
         functor_ = std::move(saved_functor_);
         browser_view_renderer_->SetCurrentCompositorFrameConsumer(
             functor_->GetCompositorFrameConsumer());
         break;
       }
       default:
         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());
     EndTest();
   }
 
  private:
   std::unique_ptr<FakeFunctor> saved_functor_;
-  OutputSurfaceResourceCountMap expected_return_count_;
+  CompositorFrameSinkResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(RenderThreadManagerSwitchTest);
 
 }  // namespace android_webview