Adds routed interface support between RenderFrameHost and RenderFrame

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 657 matching lines @@
     bool is_for_guests_only)
     : fast_shutdown_started_(false),
       deleting_soon_(false),
 #ifndef NDEBUG
       is_self_deleted_(false),
 #endif
       pending_views_(0),
       child_token_(mojo::edk::GenerateRandomToken()),
       service_worker_ref_count_(0),
       shared_worker_ref_count_(0),
+      route_provider_binding_(this),
+      associated_interface_provider_bindings_(
+          mojo::BindingSetDispatchMode::WITH_CONTEXT),
       visible_widgets_(0),
       is_process_backgrounded_(false),
       is_initialized_(false),
       id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
       browser_context_(browser_context),
       storage_partition_impl_(storage_partition_impl),
       sudden_termination_allowed_(true),
       ignore_input_events_(false),
       is_for_guests_only_(is_for_guests_only),
       gpu_observer_registered_(false),
@@ skipping 146 matching lines @@
     ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
     gpu_observer_registered_ = false;
   }
 
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
       channel_.get());
 #endif
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
-  while (!queued_messages_.empty()) {
-    delete queued_messages_.front();
+  while (!queued_messages_.empty())

[Sam McNally, 2016/09/09 05:33:14]

queued_messages_.clear();

[Ken Rockot(use gerrit already), 2016/09/09 16:01:50]

std::queue has no clear(). I've change these to destructive assignment though.

     queued_messages_.pop();
-  }
 
   UnregisterHost(GetID());
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuShaderDiskCache)) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(&RemoveShaderInfo, GetID()));
   }
 }
 
@@ skipping 102 matching lines @@
 
     // Spawn the child process asynchronously to avoid blocking the UI thread.
     // As long as there's no renderer prefix, we can use the zygote process
     // at this stage.
     child_process_launcher_.reset(new ChildProcessLauncher(
         new RendererSandboxedProcessLauncherDelegate(channel_.get()), cmd_line,
         GetID(), this, child_token_,
         base::Bind(&RenderProcessHostImpl::OnMojoError,
                    weak_factory_.GetWeakPtr(),
                    base::ThreadTaskRunnerHandle::Get())));
+    channel_->Pause();
 
     fast_shutdown_started_ = false;
   }
 
+  // Push any pending messages to the channel.now. Note that if the child

[Sam McNally, 2016/09/09 05:33:14]

s/channel.now/channel now/

[Ken Rockot(use gerrit already), 2016/09/09 16:01:50]

Done

+  // process is still launching, the channel will be paused and outgoing
+  // messages will be queued internally by the channel.
+  while (!queued_messages_.empty()) {
+    channel_->Send(queued_messages_.front().release());
+    queued_messages_.pop();
+  }
+
   if (!gpu_observer_registered_) {
     gpu_observer_registered_ = true;
     ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
   }
 
   power_monitor_broadcaster_.Init();
 
   is_initialized_ = true;
   init_time_ = base::TimeTicks::Now();
   return true;
 }
 
 std::unique_ptr<IPC::ChannelProxy> RenderProcessHostImpl::CreateChannelProxy(
     const std::string& channel_id) {
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
   IPC::mojom::ChannelBootstrapPtr bootstrap;
   GetRemoteInterfaces()->GetInterface(&bootstrap);
   std::unique_ptr<IPC::ChannelFactory> channel_factory =
       IPC::ChannelMojo::CreateServerFactory(
           bootstrap.PassInterface().PassHandle(), runner);
 
+  std::unique_ptr<IPC::ChannelProxy> channel;
   // Do NOT expand ifdef or run time condition checks here! Synchronous
   // IPCs from browser process are banned. It is only narrowly allowed
   // for Android WebView to maintain backward compatibility.
   // See crbug.com/526842 for details.
 #if defined(OS_ANDROID)
-  if (GetContentClient()->UsingSynchronousCompositing()) {
-    return IPC::SyncChannel::Create(
-        std::move(channel_factory), this, runner.get(), true, &never_signaled_);
-  }
+  if (GetContentClient()->UsingSynchronousCompositing())
+    channel = IPC::SyncChannel::Create(this, runner.get(), &never_signaled_);
 #endif  // OS_ANDROID
-
-  std::unique_ptr<IPC::ChannelProxy> channel(
-      new IPC::ChannelProxy(this, runner.get()));
+  if (!channel)
+    channel.reset(new IPC::ChannelProxy(this, runner.get()));
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->RegisterCommunicationChannel(
       channel.get(), runner);
 #endif
-  channel->Init(std::move(channel_factory), true);
+  channel->Init(std::move(channel_factory), true /* create_pipe_now */);
+
   return channel;
 }
 
 void RenderProcessHostImpl::CreateMessageFilters() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AddFilter(new ResourceSchedulerFilter(GetID()));
   MediaInternals* media_internals = MediaInternals::GetInstance();
   // Add BrowserPluginMessageFilter to ensure it gets the first stab at messages
   // from guests.
   scoped_refptr<BrowserPluginMessageFilter> bp_message_filter(
@@ skipping 181 matching lines @@
 void RenderProcessHostImpl::RegisterMojoInterfaces() {
   std::unique_ptr<shell::InterfaceRegistry> registry(
       new shell::InterfaceRegistry);
 #if defined(OS_ANDROID)
   interface_registry_android_ =
       InterfaceRegistryAndroid::Create(registry.get());
   InterfaceRegistrarAndroid::ExposeInterfacesToRenderer(
       interface_registry_android_.get());
 #endif
 
+  channel_->AddAssociatedInterface(
+      base::Bind(&RenderProcessHostImpl::OnRouteProviderRequest,
+                 base::Unretained(this)));
+
 #if !defined(OS_ANDROID)
   AddUIThreadInterface(
       registry.get(), base::Bind(&device::BatteryMonitorImpl::Create));
 #endif
   AddUIThreadInterface(
       registry.get(),
       base::Bind(&PermissionServiceContext::CreateService,
                  base::Unretained(permission_service_context_.get())));
   // TODO(mcasas): finalize arguments.
   AddUIThreadInterface(registry.get(), base::Bind(&ImageCaptureImpl::Create));
@@ skipping 55 matching lines @@
   MojoShellConnection* mojo_shell_connection =
       BrowserContext::GetMojoShellConnectionFor(browser_context_);
   std::unique_ptr<ConnectionFilterImpl> connection_filter(
       new ConnectionFilterImpl(mojo_child_connection_->child_identity(),
                                std::move(registry)));
   connection_filter_controller_ = connection_filter->controller();
   connection_filter_id_ =
       mojo_shell_connection->AddConnectionFilter(std::move(connection_filter));
 }
 
+void RenderProcessHostImpl::GetRoute(
+    int32_t routing_id,
+    mojom::AssociatedInterfaceProviderAssociatedRequest request) {
+  DCHECK(request.is_pending());
+  associated_interface_provider_bindings_.AddBinding(
+      this, std::move(request),
+      reinterpret_cast<void*>(static_cast<uintptr_t>(routing_id)));
+}
+
+void RenderProcessHostImpl::GetAssociatedInterface(
+    const std::string& name,
+    mojom::AssociatedInterfaceAssociatedRequest request) {
+  int32_t routing_id = static_cast<int32_t>(reinterpret_cast<uintptr_t>(
+      associated_interface_provider_bindings_.dispatch_context()));
+  IPC::Listener* listener = listeners_.Lookup(routing_id);
+  if (listener)
+    listener->OnAssociatedInterfaceRequest(name, request.PassHandle());
+}
+
 void RenderProcessHostImpl::CreateStoragePartitionService(
     mojo::InterfaceRequest<mojom::StoragePartitionService> request) {
   // DO NOT REMOVE THIS COMMAND LINE CHECK WITHOUT SECURITY REVIEW!
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoLocalStorage)) {
     storage_partition_impl_->Bind(std::move(request));
   }
 }
 
 int RenderProcessHostImpl::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
 
 void RenderProcessHostImpl::ResumeDeferredNavigation(
     const GlobalRequestID& request_id) {
   widget_helper_->ResumeDeferredNavigation(request_id);
 }
 
 void RenderProcessHostImpl::NotifyTimezoneChange(const std::string& zone_id) {
   Send(new ViewMsg_TimezoneChange(zone_id));
 }
 
 shell::InterfaceProvider* RenderProcessHostImpl::GetRemoteInterfaces() {
   return mojo_child_connection_->GetRemoteInterfaces();
 }
 
+mojom::RouteProvider* RenderProcessHostImpl::GetRemoteRouteProvider() {
+  if (!remote_route_provider_) {
+    DCHECK(channel_);
+    channel_->GetRemoteAssociatedInterface(&remote_route_provider_);
+  }
+  return remote_route_provider_.get();
+}
+
 std::unique_ptr<base::SharedPersistentMemoryAllocator>
 RenderProcessHostImpl::TakeMetricsAllocator() {
   return std::move(metrics_allocator_);
 }
 
 const base::TimeTicks& RenderProcessHostImpl::GetInitTimeForNavigationMetrics()
     const {
   return init_time_;
 }
 
@@ skipping 48 matching lines @@
 }
 
 void RenderProcessHostImpl::AddRoute(int32_t routing_id,
                                      IPC::Listener* listener) {
   CHECK(!listeners_.Lookup(routing_id)) << "Found Routing ID Conflict: "
                                         << routing_id;
   listeners_.AddWithID(listener, routing_id);
 }
 
 void RenderProcessHostImpl::RemoveRoute(int32_t routing_id) {
-  DCHECK(listeners_.Lookup(routing_id) != NULL);
+  DCHECK(listeners_.Lookup(routing_id) != nullptr);
   listeners_.Remove(routing_id);
   Cleanup();
 }
 
 void RenderProcessHostImpl::AddObserver(RenderProcessHostObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RenderProcessHostImpl::RemoveObserver(
     RenderProcessHostObserver* observer) {
@@ skipping 484 matching lines @@
   // Set this before ProcessDied() so observers can tell if the render process
   // died due to fast shutdown versus another cause.
   fast_shutdown_started_ = true;
 
   ProcessDied(false /* already_dead */, nullptr);
   return true;
 }
 
 bool RenderProcessHostImpl::Send(IPC::Message* msg) {
   TRACE_EVENT0("renderer_host", "RenderProcessHostImpl::Send");
+
+  std::unique_ptr<IPC::Message> message(msg);
+
 #if !defined(OS_ANDROID)
-  DCHECK(!msg->is_sync());
+  DCHECK(!message->is_sync());
 #endif
 
   if (!channel_) {
 #if defined(OS_ANDROID)
-    if (msg->is_sync()) {
-      delete msg;
+    if (message->is_sync())
       return false;
-    }
 #endif
     if (!is_initialized_) {
-      queued_messages_.push(msg);
+      queued_messages_.emplace(std::move(message));
       return true;
-    } else {
-      delete msg;
-      return false;
     }
+    return false;
   }
 
-  if (child_process_launcher_.get() && child_process_launcher_->IsStarting()) {
 #if defined(OS_ANDROID)
-    if (msg->is_sync()) {
-      delete msg;
-      return false;
-    }
+  if (child_process_launcher_.get() && child_process_launcher_->IsStarting() &&
+      message->is_sync()) {
+    return false;
+  }
 #endif
-    queued_messages_.push(msg);
-    return true;
-  }
 
-  return channel_->Send(msg);
+  return channel_->Send(message.release());
 }
 
 bool RenderProcessHostImpl::OnMessageReceived(const IPC::Message& msg) {
   // If we're about to be deleted, or have initiated the fast shutdown sequence,
   // we ignore incoming messages.
 
   if (deleting_soon_ || fast_shutdown_started_)
     return false;
 
   mark_child_process_activity_time();
@@ skipping 635 matching lines @@
     return;
   metrics_allocator_.reset(new base::SharedPersistentMemoryAllocator(
       std::move(shm), GetID(), "RendererMetrics", /*readonly=*/false));
 
   base::SharedMemoryHandle shm_handle;
   metrics_allocator_->shared_memory()->ShareToProcess(destination, &shm_handle);
   Send(new ChildProcessMsg_SetHistogramMemory(
       shm_handle, metrics_allocator_->shared_memory()->mapped_size()));
 }
 
+void RenderProcessHostImpl::OnRouteProviderRequest(
+    mojom::RouteProviderAssociatedRequest request) {
+  if (route_provider_binding_.is_bound())
+    return;
+  route_provider_binding_.Bind(std::move(request));
+}
+
 void RenderProcessHostImpl::ProcessDied(bool already_dead,
                                         RendererClosedDetails* known_details) {
   // Our child process has died.  If we didn't expect it, it's a crash.
   // In any case, we need to let everyone know it's gone.
   // The OnChannelError notification can fire multiple times due to nested sync
   // calls to a renderer. If we don't have a valid channel here it means we
   // already handled the error.
 
   // It should not be possible for us to be called re-entrantly.
   DCHECK(!within_process_died_observer_);
@@ skipping 24 matching lines @@
   }
 
   RendererClosedDetails details(status, exit_code);
 
   child_process_launcher_.reset();
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
       channel_.get());
 #endif
   channel_.reset();
-  while (!queued_messages_.empty()) {
-    delete queued_messages_.front();
+  while (!queued_messages_.empty())
     queued_messages_.pop();
-  }
   UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 
   // RenderProcessExited observers and RenderProcessGone handlers might
   // navigate or perform other actions that require a connection. Ensure that
   // there is one before calling them.
   child_token_ = mojo::edk::GenerateRandomToken();
   shell::Connector* connector =
       BrowserContext::GetShellConnectorFor(browser_context_);
   if (!connector)
@@ skipping 130 matching lines @@
   // especially don't want to send the RENDERER_PROCESS_CREATED notification,
   // since some clients might expect a RENDERER_PROCESS_TERMINATED afterwards to
   // properly cleanup.
   if (deleting_soon_)
     return;
 
   if (child_process_launcher_) {
     DCHECK(child_process_launcher_->GetProcess().IsValid());
     DCHECK(!is_process_backgrounded_);
 
+    // Unpause the channel now that the process is launched. We don't flush it
+    // yet to ensure that any initialization messages sent here (e.g., things
+    // done in response to NOTIFICATION_RENDER_PROCESS_CREATED; see below)
+    // preempt already queued messages.
+    channel_->Unpause(false /* flush */);
+
     if (mojo_child_connection_) {
       mojo_child_connection_->SetProcessHandle(
           child_process_launcher_->GetProcess().Handle());
     }
 
     // Not all platforms launch processes in the same backgrounded state. Make
     // sure |is_process_backgrounded_| reflects this platform's initial process
     // state.
     is_process_backgrounded_ =
         child_process_launcher_->GetProcess().IsProcessBackgrounded();
 
     // Disable updating process priority on startup for now as it incorrectly
     // results in backgrounding foreground navigations until their first commit
     // is made. A better long term solution would be to be aware of the tab's
     // visibility at this point. https://crbug.com/560446.
     // Except on Android for now because of https://crbug.com/601184 :-(.
 #if defined(OS_ANDROID)
     UpdateProcessPriority();
 #endif
 
     // Share histograms between the renderer and this process.
     CreateSharedRendererHistogramAllocator();
   }
 
-  // NOTE: This needs to be before sending queued messages because
+  // NOTE: This needs to be before flushing queued messages, because
   // ExtensionService uses this notification to initialize the renderer process
   // with state that must be there before any JavaScript executes.
   //
   // The queued messages contain such things as "navigate". If this notification
   // was after, we can end up executing JavaScript before the initialization
   // happens.
   NotificationService::current()->Notify(NOTIFICATION_RENDERER_PROCESS_CREATED,
                                          Source<RenderProcessHost>(this),
                                          NotificationService::NoDetails());
 
-  while (!queued_messages_.empty()) {
-    Send(queued_messages_.front());
-    queued_messages_.pop();
-  }
+  if (child_process_launcher_)
+    channel_->Flush();
 
   if (IsReady()) {
     DCHECK(!sent_render_process_ready_);
     sent_render_process_ready_ = true;
     // Send RenderProcessReady only if the channel is already connected.
     FOR_EACH_OBSERVER(RenderProcessHostObserver,
                       observers_,
                       RenderProcessReady(this));
   }
 
@@ skipping 142 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing. Alias
   // enough information here so that we can determine what the bad message was.
   base::debug::Alias(&error);
   bad_message::ReceivedBadMessage(process.get(),
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content