Use MojoCompositorFrameSink in RendererCompositorFrameSink

content/browser/renderer_host/delegated_frame_host.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 "content/browser/renderer_host/delegated_frame_host.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 360 matching lines @@
 
   // To avoid unnecessary browser composites, try to go directly to the Surface
   // rather than through the Layer (which goes through the browser compositor).
   if (has_frame_ && request_copy_of_output_callback_for_testing_.is_null()) {
     support_->RequestCopyOfSurface(std::move(request));
   } else {
     RequestCopyOfOutput(std::move(request));
   }
 }
 
-void DelegatedFrameHost::DidCreateNewRendererCompositorFrameSink() {
+void DelegatedFrameHost::DidCreateNewRendererCompositorFrameSink(
+    cc::mojom::MojoCompositorFrameSinkClient* renderer_compositor_frame_sink) {
   ResetCompositorFrameSinkSupport();
+  renderer_compositor_frame_sink_ = renderer_compositor_frame_sink;
   CreateCompositorFrameSinkSupport();
   has_frame_ = false;
 }
 
 void DelegatedFrameHost::SubmitCompositorFrame(
     const cc::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame) {
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
 #endif
@@ skipping 14 matching lines @@
       gfx::ConvertRectToDIP(frame_device_scale_factor, damage_rect);
 
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::ReturnedResourceArray resources;
     cc::TransferableResource::ReturnResources(frame.resource_list, &resources);
 
     skipped_latency_info_list_.insert(skipped_latency_info_list_.end(),
                                       frame.metadata.latency_info.begin(),
                                       frame.metadata.latency_info.end());
 
-    client_->DelegatedFrameHostSendReclaimCompositorResources(
-        true /* is_swap_ack*/, resources);
+    renderer_compositor_frame_sink_->ReclaimResources(resources);
+    renderer_compositor_frame_sink_->DidReceiveCompositorFrameAck();
+
     skipped_frames_ = true;
     BeginFrameDidNotSwap(ack);
     return;
   }
 
   // If we are allowing one renderer frame through, this would ensure the frame
   // gets through even if we regrab the lock after the UI compositor makes one
   // frame. If the renderer frame beats the UI compositor, then we don't need to
   // allow any more, though.
   allow_one_renderer_frame_during_resize_lock_ = false;
@@ skipping 58 matching lines @@
   // Note: the frame may have been evicted immediately.
 
   DidFinishFrame(ack);
 }
 
 void DelegatedFrameHost::ClearDelegatedFrame() {
   EvictDelegatedFrame();
 }
 
 void DelegatedFrameHost::DidReceiveCompositorFrameAck() {
-  client_->DelegatedFrameHostSendReclaimCompositorResources(
-      true /* is_swap_ack */, cc::ReturnedResourceArray());
+  renderer_compositor_frame_sink_->DidReceiveCompositorFrameAck();
 }
 
 void DelegatedFrameHost::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
-  client_->DelegatedFrameHostSendReclaimCompositorResources(
-      false /* is_swap_ack */, resources);
+  renderer_compositor_frame_sink_->ReclaimResources(resources);
 }
 
 void DelegatedFrameHost::WillDrawSurface(const cc::LocalSurfaceId& id,
                                          const gfx::Rect& damage_rect) {
   // Frame subscribers are only interested in changes to the target surface, so
   // do not attempt capture if |damage_rect| is empty.  This prevents the draws
   // of parent surfaces from triggering extra frame captures, which can affect
   // smoothness.
   if (id != local_surface_id_ || damage_rect.IsEmpty())
     return;
@@ skipping 347 matching lines @@
   }
 
   if (!skipped_frames_) {
     latest_confirmed_begin_frame_source_id_ = ack.source_id;
     latest_confirmed_begin_frame_sequence_number_ =
         ack.latest_confirmed_sequence_number;
   }
 }
 
 }  // namespace content