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 278 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_GENERIC(ViewHostMsg_SwapCompositorFrame,
-                                OnSwapCompositorFrame(msg))
-    IPC_MESSAGE_HANDLER(ViewHostMsg_BeginFrameDidNotSwap,
-                        OnBeginFrameDidNotSwap)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_BeginFrameDidNotSwap, BeginFrameDidNotSwap)
     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 1011 matching lines @@
   SendScreenRects();
 }
 
 void RenderWidgetHostImpl::OnRequestMove(const gfx::Rect& pos) {
   if (view_) {
     view_->SetBounds(pos);
     Send(new ViewMsg_Move_ACK(routing_id_));
   }
 }
 
-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) {
+void RenderWidgetHostImpl::BeginFrameDidNotSwap(const cc::BeginFrameAck& ack) {
   if (ack.sequence_number < cc::BeginFrameArgs::kStartingFrameNumber) {
     // Received an invalid ack, renderer misbehaved.
     bad_message::ReceivedBadMessage(
         GetProcess(), bad_message::RWH_INVALID_BEGIN_FRAME_ACK_DID_NOT_SWAP);
     return;
   }
 
   // |has_damage| is not transmitted.
   cc::BeginFrameAck modified_ack = ack;
   modified_ack.has_damage = false;
@@ skipping 422 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 215 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
+  renderer_compositor_frame_sink_ = std::move(client);
+  if (view_) {
+    view_->DidCreateNewRendererCompositorFrameSink(
+        renderer_compositor_frame_sink_.get());

[piman, 2017/04/10 23:35:57]

So, if the MojoCompositorFrameSinkClient is recreated, here, we'll call into the
view, passing the new one, while it still has a raw pointer to the old one
(which I assume is deleted on l.2601). Is that safe - is there a chance the view
might access the old one to try to return resources or something?
If so, should we keep a reference to the old bindings until after this?

[Saman Sami, 2017/04/11 00:09:52]

That's a good point. I think it's better to do that.

+  }
+}
+
+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 should not send empty frames.
   if (frame.render_pass_list.empty()) {
     DLOG(ERROR) << "Renderer sent an empty frame.";
     return;
   }
 
   // The renderer must allocate a new LocalSurfaceId if frame size or device
@@ skipping 50 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);
-    SendReclaimCompositorResources(true /* is_swap_ack */, resources);
+    renderer_compositor_frame_sink_->ReclaimResources(resources);
+    renderer_compositor_frame_sink_->DidReceiveCompositorFrameAck();

[piman, 2017/04/10 23:35:58]

Could we avoid splitting this into 2 IPCs?

[Saman Sami, 2017/04/11 00:09:52]

I proposed that, but other folks objected because DidReceiveCompositorFrameAck
is going away. I don't disagree with you though. Is the overhead of an
additional IPC significant?

   }
 
   // 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