Revert "Use MojoCompositorFrameSink in RendererCompositorFrameSink"

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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/render_widget_host_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 280 matching lines @@
       owned_by_render_frame_host_(false),
       is_focused_(false),
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       hang_monitor_event_type_(blink::WebInputEvent::kUndefined),
       last_event_type_(blink::WebInputEvent::kUndefined),
       new_content_rendering_delay_(
           base::TimeDelta::FromMilliseconds(kNewContentRenderingDelayMs)),
       current_content_source_id_(0),
       monitoring_composition_info_(false),
-      compositor_frame_sink_binding_(this),
       weak_factory_(this) {
   CHECK(delegate_);
   CHECK_NE(MSG_ROUTING_NONE, routing_id_);
   latency_tracker_.SetDelegate(delegate_);
 
   DCHECK(base::TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
 #if defined(OS_WIN)
   // Update the display color profile cache so that it is likely to be up to
   // date when the renderer process requests the color profile.
@@ skipping 95 matching lines @@
 }
 
 // static
 RenderWidgetHostImpl* RenderWidgetHostImpl::From(RenderWidgetHost* rwh) {
   return static_cast<RenderWidgetHostImpl*>(rwh);
 }
 
 void RenderWidgetHostImpl::SetView(RenderWidgetHostViewBase* view) {
   if (view) {
     view_ = view->GetWeakPtr();
-    if (renderer_compositor_frame_sink_.is_bound()) {
-      view->DidCreateNewRendererCompositorFrameSink(
-          renderer_compositor_frame_sink_.get());
-    }
     // Views start out not needing begin frames, so only update its state
     // if the value has changed.
     if (needs_begin_frames_)
       view_->SetNeedsBeginFrames(needs_begin_frames_);
   } else {
     view_.reset();
   }
 
   synthetic_gesture_controller_.reset();
 }
@@ skipping 125 matching lines @@
     IPC_MESSAGE_HANDLER(FrameHostMsg_HittestData, OnHittestData)
     IPC_MESSAGE_HANDLER(InputHostMsg_QueueSyntheticGesture,
                         OnQueueSyntheticGesture)
     IPC_MESSAGE_HANDLER(InputHostMsg_ImeCancelComposition,
                         OnImeCancelComposition)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Close, OnClose)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateScreenRects_ACK,
                         OnUpdateScreenRectsAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestMove, OnRequestMove)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetTooltipText, OnSetTooltipText)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_BeginFrameDidNotSwap, BeginFrameDidNotSwap)
+    IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_SwapCompositorFrame,
+                                OnSwapCompositorFrame(msg))
+    IPC_MESSAGE_HANDLER(ViewHostMsg_BeginFrameDidNotSwap,
+                        OnBeginFrameDidNotSwap)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnUpdateRect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetCursor, OnSetCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_TextInputStateChanged,
                         OnTextInputStateChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_LockMouse, OnLockMouse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UnlockMouse, OnUnlockMouse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowDisambiguationPopup,
                         OnShowDisambiguationPopup)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectionBoundsChanged,
                         OnSelectionBoundsChanged)
@@ skipping 288 matching lines @@
 
 bool RenderWidgetHostImpl::CanPauseForPendingResizeOrRepaints() {
   // Do not pause if the view is hidden.
   if (is_hidden())
     return false;
 
   // Do not pause if there is not a paint or resize already coming.
   if (!repaint_ack_pending_ && !resize_ack_pending_)
     return false;
 
-  if (!renderer_compositor_frame_sink_.is_bound())
-    return false;
-
   return true;
 }
 
 void RenderWidgetHostImpl::WaitForSurface() {
   // How long to (synchronously) wait for the renderer to respond with a
   // new frame when our current frame doesn't exist or is the wrong size.
   // This timeout impacts the "choppiness" of our window resize.
   const int kPaintMsgTimeoutMS = 50;
 
   if (!view_)
@@ skipping 1030 matching lines @@
   SendScreenRects();
 }
 
 void RenderWidgetHostImpl::OnRequestMove(const gfx::Rect& pos) {
   if (view_) {
     view_->SetBounds(pos);
     Send(new ViewMsg_Move_ACK(routing_id_));
   }
 }
 
-void RenderWidgetHostImpl::BeginFrameDidNotSwap(const cc::BeginFrameAck& ack) {
+bool RenderWidgetHostImpl::OnSwapCompositorFrame(const IPC::Message& message) {
+  // This trace event is used in
+  // chrome/browser/extensions/api/cast_streaming/performance_test.cc
+  TRACE_EVENT0("test_fps,benchmark", "OnSwapCompositorFrame");
+
+  ViewHostMsg_SwapCompositorFrame::Param param;
+  if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
+    return false;
+  uint32_t compositor_frame_sink_id = std::get<0>(param);
+  cc::LocalSurfaceId local_surface_id = std::get<1>(param);
+  cc::CompositorFrame frame(std::move(std::get<2>(param)));
+
+  if (compositor_frame_sink_id != last_compositor_frame_sink_id_) {
+    if (view_)
+      view_->DidCreateNewRendererCompositorFrameSink();
+    last_compositor_frame_sink_id_ = compositor_frame_sink_id;
+  }
+
+  SubmitCompositorFrame(local_surface_id, std::move(frame));
+
+  return true;
+}
+
+void RenderWidgetHostImpl::OnBeginFrameDidNotSwap(
+    const cc::BeginFrameAck& ack) {
   // |has_damage| is not transmitted.
   cc::BeginFrameAck modified_ack = ack;
   modified_ack.has_damage = false;
 
   if (view_)
     view_->OnBeginFrameDidNotSwap(modified_ack);
 }
 
 void RenderWidgetHostImpl::OnUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
@@ skipping 416 matching lines @@
   pending_mouse_lock_request_ = false;
   if (!view_ || !view_->HasFocus()|| !view_->LockMouse()) {
     Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
     return false;
   }
 
   Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
   return true;
 }
 
+void RenderWidgetHostImpl::SendReclaimCompositorResources(
+    bool is_swap_ack,
+    const cc::ReturnedResourceArray& resources) {
+  Send(new ViewMsg_ReclaimCompositorResources(
+      routing_id_, last_compositor_frame_sink_id_, is_swap_ack, resources));
+}
+
 void RenderWidgetHostImpl::DelayedAutoResized() {
   gfx::Size new_size = new_auto_size_;
   // Clear the new_auto_size_ since the empty value is used as a flag to
   // indicate that no callback is in progress (i.e. without this line
   // DelayedAutoResized will not get called again).
   new_auto_size_.SetSize(0, 0);
   if (!auto_resize_enabled_)
     return;
 
   if (delegate_)
@@ skipping 140 matching lines @@
 
 void RenderWidgetHostImpl::RequestCompositionUpdates(bool immediate_request,
                                                      bool monitor_updates) {
   if (!immediate_request && monitor_updates == monitoring_composition_info_)
     return;
   monitoring_composition_info_ = monitor_updates;
   Send(new InputMsg_RequestCompositionUpdates(routing_id_, immediate_request,
                                               monitor_updates));
 }
 
-void RenderWidgetHostImpl::RequestMojoCompositorFrameSink(
-    cc::mojom::MojoCompositorFrameSinkRequest request,
-    cc::mojom::MojoCompositorFrameSinkClientPtr client) {
-  if (compositor_frame_sink_binding_.is_bound())
-    compositor_frame_sink_binding_.Close();
-#if defined(OS_MACOSX)
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      ui::WindowResizeHelperMac::Get()->task_runner();
-  // In tests, task_runner might not be initialized.
-  if (task_runner)
-    compositor_frame_sink_binding_.Bind(std::move(request), task_runner);
-  else
-    compositor_frame_sink_binding_.Bind(std::move(request));
-#else
-  compositor_frame_sink_binding_.Bind(std::move(request));
-#endif
-  if (view_)
-    view_->DidCreateNewRendererCompositorFrameSink(client.get());
-  renderer_compositor_frame_sink_ = std::move(client);
-}
-
-void RenderWidgetHostImpl::SetNeedsBeginFrame(bool needs_begin_frame) {
-  OnSetNeedsBeginFrames(needs_begin_frame);
-}
-
 void RenderWidgetHostImpl::SubmitCompositorFrame(
     const cc::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame) {
   // The renderer must allocate a new LocalSurfaceId if frame size or device
   // scale factor changes.
   float device_scale_factor = frame.metadata.device_scale_factor;
   const gfx::Size& frame_size =
       frame.render_pass_list.back()->output_rect.size();
   if (local_surface_id == last_local_surface_id_ &&
       (frame_size != last_frame_size_ ||
@@ skipping 36 matching lines @@
   // stale graphics on top-level frames. We accept frames that have a source ID
   // greater than |current_content_source_id_| because in some cases the first
   // compositor frame can arrive before the navigation commit message that
   // updates that value.
   if (view_ && frame.metadata.content_source_id >= current_content_source_id_) {
     view_->SubmitCompositorFrame(local_surface_id, std::move(frame));
     view_->DidReceiveRendererFrame();
   } else {
     cc::ReturnedResourceArray resources;
     cc::TransferableResource::ReturnResources(frame.resource_list, &resources);
-    renderer_compositor_frame_sink_->DidReceiveCompositorFrameAck(resources);
+    SendReclaimCompositorResources(true /* is_swap_ack */, resources);
   }
 
   // After navigation, if a frame belonging to the new page is received, stop
   // the timer that triggers clearing the graphics of the last page.
   if (last_received_content_source_id_ >= current_content_source_id_ &&
       new_content_rendering_timeout_->IsRunning()) {
     new_content_rendering_timeout_->Stop();
   }
 
   if (delegate_)
@@ skipping 25 matching lines @@
   RenderProcessHost* rph = GetProcess();
   for (std::vector<IPC::Message>::const_iterator i = messages.begin();
        i != messages.end(); ++i) {
     rph->OnMessageReceived(*i);
     if (i->dispatch_error())
       rph->OnBadMessageReceived(*i);
   }
 }
 
 }  // namespace content