Fork cc::OutputSurface into cc::CompositorFrameSink.

android_webview/browser/browser_view_renderer.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 "android_webview/browser/browser_view_renderer.h"
 
 #include <utility>
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/child_frame.h"
@@ skipping 244 matching lines @@
   TRACE_EVENT0("android_webview",
                "BrowserViewRenderer::OnDrawHardwareProcessFrame");
   if (!frame.frame)
     return;
 
   gfx::Transform transform_for_tile_priority =
       external_draw_constraints_.transform;
   gfx::Rect viewport_rect_for_tile_priority =
       ComputeViewportRectForTilePriority();
   std::unique_ptr<ChildFrame> child_frame = base::MakeUnique<ChildFrame>(
-      frame.output_surface_id, std::move(frame.frame), compositor_id_,
+      frame.compositor_frame_sink_id, std::move(frame.frame), compositor_id_,
       viewport_rect_for_tile_priority.IsEmpty(), transform_for_tile_priority,
       offscreen_pre_raster_, external_draw_constraints_.is_layer);
 
   ReturnUnusedResource(
       current_compositor_frame_consumer_->PassUncommittedFrameOnUI());
   current_compositor_frame_consumer_->SetFrameOnUI(std::move(child_frame));
 }
 
 gfx::Rect BrowserViewRenderer::ComputeViewportRectForTilePriority() {
   // If the WebView is on a layer, WebView does not know what transform is
@@ skipping 39 matching lines @@
     std::unique_ptr<ChildFrame> child_frame) {
   if (!child_frame.get() || !child_frame->frame.get())
     return;
 
   cc::ReturnedResourceArray resources;
   cc::TransferableResource::ReturnResources(
       child_frame->frame->delegated_frame_data->resource_list, &resources);
   content::SynchronousCompositor* compositor =
       FindCompositor(child_frame->compositor_id);
   if (compositor && !resources.empty())
-    compositor->ReturnResources(child_frame->output_surface_id, resources);
+    compositor->ReturnResources(child_frame->compositor_frame_sink_id,
+                                resources);
 }
 
 void BrowserViewRenderer::ReturnResourceFromParent(
     CompositorFrameConsumer* compositor_frame_consumer) {
   CompositorFrameConsumer::ReturnedResourcesMap returned_resource_map;
   compositor_frame_consumer->SwapReturnedResourcesOnUI(&returned_resource_map);
   for (auto& pair : returned_resource_map) {
     CompositorID compositor_id = pair.first;
     content::SynchronousCompositor* compositor = FindCompositor(compositor_id);
     cc::ReturnedResourceArray resources;
     resources.swap(pair.second.resources);
 
     if (compositor && !resources.empty()) {
-      compositor->ReturnResources(pair.second.output_surface_id, resources);
+      compositor->ReturnResources(pair.second.compositor_frame_sink_id,
+                                  resources);
     }
   }
 }
 
 bool BrowserViewRenderer::OnDrawSoftware(SkCanvas* canvas) {
   return CanOnDraw() && CompositeSW(canvas);
 }
 
 sk_sp<SkPicture> BrowserViewRenderer::CapturePicture(int width,
                                                      int height) {
@@ skipping 415 matching lines @@
   base::StringAppendF(&str,
                       "overscroll_rounding_error_: %s ",
                       overscroll_rounding_error_.ToString().c_str());
   base::StringAppendF(
       &str, "on_new_picture_enable: %d ", on_new_picture_enable_);
   base::StringAppendF(&str, "clear_view: %d ", clear_view_);
   return str;
 }
 
 }  // namespace android_webview