Deliver IPC messages together with SwapCompositorFrame

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 <utility>
 
@@ skipping 1444 matching lines @@
   // This trace event is used in
   // chrome/browser/extensions/api/cast_streaming/performance_test.cc
   UNSHIPPED_TRACE_EVENT0("test_fps",
                          TRACE_DISABLED_BY_DEFAULT("OnSwapCompositorFrame"));
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return false;
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   uint32 output_surface_id = param.a;
   param.b.AssignTo(frame.get());
+  std::vector<IPC::Message> messages_to_deliver_with_frame;
+  messages_to_deliver_with_frame.swap(param.c);
 
   for (size_t i = 0; i < frame->metadata.latency_info.size(); i++)
     AddLatencyInfoComponentIds(&frame->metadata.latency_info[i]);
 
   input_router_->OnViewUpdated(
       GetInputRouterViewFlagsFromCompositorFrameMetadata(frame->metadata));
 
   if (view_) {
     view_->OnSwapCompositorFrame(output_surface_id, frame.Pass());
     view_->DidReceiveRendererFrame();
   } else {
     cc::CompositorFrameAck ack;
     if (frame->gl_frame_data) {
       ack.gl_frame_data = frame->gl_frame_data.Pass();
       ack.gl_frame_data->sync_point = 0;
     } else if (frame->delegated_frame_data) {
       cc::TransferableResource::ReturnResources(
           frame->delegated_frame_data->resource_list,
           &ack.resources);
     } else if (frame->software_frame_data) {
       ack.last_software_frame_id = frame->software_frame_data->id;
     }
     SendSwapCompositorFrameAck(routing_id_, output_surface_id,
                                process_->GetID(), ack);
   }
+
+  RenderProcessHost* rph = GetProcess();
+  for (std::vector<IPC::Message>::const_iterator i =
+           messages_to_deliver_with_frame.begin();
+       i != messages_to_deliver_with_frame.end();
+       ++i) {
+    rph->OnMessageReceived(*i);

[Tom Sepez, 2014/07/02 17:56:04]

You should check if the message was handled, calling BadMessageReceived().

[jam, 2014/07/02 20:10:54]

In general, not handling IPCs is not considered an error. In which case this
would be:

if (i->dispatch_error())
  rph->OnBadMessageReceived(*i);


However, RenderWidget::QueueMessage is somewhat error prone because it only
delivers the queued IPCs to the RPH. That means any IPC currently dispatched by
a BrowserMessageFilter wouldn't work if someone used QueueMessage to send them.

I'm wondering why we need this generic infrastructure. Do we expect more IPCs to
be queued like this? I only see FrameHostMsg_DidFirstVisuallyNonEmptyPaint using
this now, is that correct? If it's just that one IPC, can we do a one-off
solution?

[mkosiba (inactive), 2014/07/03 15:47:32]

Done.
The value of RenderWidget::QueueMessage is that we deliver the messages together
with the frame swap notification, so posting back to the IO thread to run the
filters from here would make it less useful.

Getting message filters to work transparently would essentially require cracking
this message open on the IO thread, filtering the inner messages vector and
forwarding the 'filtered' message on, right?

For now the intent is not to provide a drop-in replacement for IPC.
So I only used DidFirstVisuallyNonEmptyPaint as a guinea pig. I'm working a CL
that uses this mechanism to implement some new webview functionality and piman@
was interested in using this for LatencyInfo and ViewHostMsg_UpdateRect (see
comment #4).

+  }
+  messages_to_deliver_with_frame.clear();
+
   return true;
 }
 
 void RenderWidgetHostImpl::OnFlingingStopped() {
   if (view_)
     view_->DidStopFlinging();
 }
 
 void RenderWidgetHostImpl::OnUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
@@ skipping 868 matching lines @@
   }
 }
 
 SkBitmap::Config RenderWidgetHostImpl::PreferredReadbackFormat() {
   if (view_)
     return view_->PreferredReadbackFormat();
   return SkBitmap::kARGB_8888_Config;
 }
 
 }  // namespace content