Move FrameMsg_NewFrame/NewFrameProxy to mojom

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 157 matching lines @@
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "ipc/attachment_broker.h"
 #include "ipc/attachment_broker_privileged.h"
 #include "ipc/ipc.mojom.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "services/shell/runner/common/switches.h"
 #include "storage/browser/fileapi/sandbox_file_system_backend.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/display/display_switches.h"
@@ skipping 54 matching lines @@
 
 #if defined(OS_WIN)
 #define IntToStringType base::IntToString16
 #else
 #define IntToStringType base::IntToString
 #endif
 
 namespace content {
 namespace {
 
+const char kRendererInterfaceKeyName[] = "mojom_renderer_interface";
 const char kSiteProcessMapKeyName[] = "content_site_process_map";
 
 #ifdef ENABLE_WEBRTC
 const base::FilePath::CharType kAecDumpFileNameAddition[] =
     FILE_PATH_LITERAL("aec_dump");
 #endif
 
 void CacheShaderInfo(int32_t id, base::FilePath path) {
   ShaderCacheFactory::GetInstance()->SetCacheInfo(id, path);
 }
@@ skipping 96 matching lines @@
   DCHECK(context);
   SiteProcessMap* map = static_cast<SiteProcessMap*>(
       context->GetUserData(kSiteProcessMapKeyName));
   if (!map) {
     map = new SiteProcessMap();
     context->SetUserData(kSiteProcessMapKeyName, map);
   }
   return map;
 }
 
+// Holds a Mojo associated interface proxy in an RPH's user data.
+template <typename Interface>
+class AssociatedInterfaceHolder : public base::SupportsUserData::Data {
+ public:
+  AssociatedInterfaceHolder() {}
+  ~AssociatedInterfaceHolder() override {}
+
+  mojo::AssociatedInterfacePtr<Interface>& proxy() { return proxy_; }
+
+ private:
+  mojo::AssociatedInterfacePtr<Interface> proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssociatedInterfaceHolder);
+};
+
 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 // This static member variable holds the zygote communication information for
 // the renderer.
 ZygoteHandle g_render_zygote;
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 // NOTE: changes to this class need to be reviewed by the security team.
 class RendererSandboxedProcessLauncherDelegate
     : public SandboxedProcessLauncherDelegate {
  public:
@@ skipping 450 matching lines @@
 void RenderProcessHostImpl::EnableSendQueue() {
   is_initialized_ = false;
 }
 
 bool RenderProcessHostImpl::Init() {
   // calling Init() more than once does nothing, this makes it more convenient
   // for the view host which may not be sure in some cases
   if (channel_)
     return true;
 
-  // Ensure that the remote associated interfaces are re-initialized on next
-  // access since they're associated with a specific Channel instance.
-  remote_route_provider_.reset();
-  renderer_interface_.reset();
-
   base::CommandLine::StringType renderer_prefix;
   // A command prefix is something prepended to the command line of the spawned
   // process.
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
   renderer_prefix =
       browser_command_line.GetSwitchValueNative(switches::kRendererCmdPrefix);
 
 #if defined(OS_LINUX)
   int flags = renderer_prefix.empty() ? ChildProcessHost::CHILD_ALLOW_SELF
                                       : ChildProcessHost::CHILD_NORMAL;
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
   // Find the renderer before creating the channel so if this fails early we
   // return without creating the channel.
   base::FilePath renderer_path = ChildProcessHost::GetChildPath(flags);
   if (renderer_path.empty())
     return false;
 
   channel_connected_ = false;
   sent_render_process_ready_ = false;
 
   // Setup the IPC channel.
   const std::string channel_id =
       IPC::Channel::GenerateVerifiedChannelID(std::string());
   channel_ = CreateChannelProxy(channel_id);
 
+  // Note that Channel send is effectively paused and unpaused at various points
+  // during startup, and existing code relies on a fragile relative message
+  // ordering resulting from some early messages being queued until process
+  // launch while others are sent immediately.
+  //
+  // We acquire a few associated interface proxies here -- before the channel is
+  // paused -- to ensure that subsequent initialization messages on those
+  // interfaces behave properly. Specifically, this avoids the risk of an
+  // interface being requested while the Channel is paused, effectively
+  // blocking the transmission of a subsequent message on the interface which
+  // may be sent while the Channel is unpaused.
+  //
+  // See OnProcessLaunched() for some additional details of this somewhat
+  // surprising behavior.
+  channel_->GetRemoteAssociatedInterface(&remote_route_provider_);
+
+  std::unique_ptr<AssociatedInterfaceHolder<mojom::Renderer>> holder =
+      base::MakeUnique<AssociatedInterfaceHolder<mojom::Renderer>>();
+  channel_->GetRemoteAssociatedInterface(&holder->proxy());
+  SetUserData(kRendererInterfaceKeyName, holder.release());
+
   // Call the embedder first so that their IPC filters have priority.
   GetContentClient()->browser()->RenderProcessWillLaunch(this);
 
 #if !defined(OS_MACOSX)
   // Intentionally delay the hang monitor creation after the first renderer
   // is created. On Mac audio thread is the UI thread, a hang monitor is not
   // necessary or recommended.
   media::AudioManager::StartHangMonitorIfNeeded(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
 #endif  // !defined(OS_MACOSX)
@@ skipping 498 matching lines @@
 bool RenderProcessHostImpl::IsWorkerRefCountDisabled() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return is_worker_ref_count_disabled_;
 }
 
 void RenderProcessHostImpl::PurgeAndSuspend() {
   Send(new ChildProcessMsg_PurgeAndSuspend());
 }
 
 mojom::RouteProvider* RenderProcessHostImpl::GetRemoteRouteProvider() {
-  if (!remote_route_provider_) {
-    DCHECK(channel_);
-    channel_->GetRemoteAssociatedInterface(&remote_route_provider_);
-  }
   return remote_route_provider_.get();
 }
 
-mojom::Renderer* RenderProcessHostImpl::GetRendererInterface() {
-  if (!renderer_interface_) {
-    DCHECK(channel_);
-    channel_->GetRemoteAssociatedInterface(&renderer_interface_);
+// static
+mojom::Renderer* RenderProcessHostImpl::GetRendererInterface(
+    RenderProcessHost* host) {
+  AssociatedInterfaceHolder<mojom::Renderer>* holder =
+      static_cast<AssociatedInterfaceHolder<mojom::Renderer>*>(
+          host->GetUserData(kRendererInterfaceKeyName));
+  if (!holder) {
+    // In tests, MockRenderProcessHost will not have initialized this key on its
+    // own. We do it with a dead-end endpoint so outgoing requests are silently
+    // dropped.
+    holder = new AssociatedInterfaceHolder<mojom::Renderer>;
+    host->SetUserData(kRendererInterfaceKeyName, holder);
+    mojo::GetDummyProxyForTesting(&holder->proxy());
   }
-  return renderer_interface_.get();
+
+  return holder->proxy().get();
 }
 
 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) {
@@ skipping 1233 matching lines @@
   RendererClosedDetails details(status, exit_code);
 
   child_process_launcher_.reset();
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
       channel_.get());
 #endif
   channel_.reset();
   queued_messages_ = MessageQueue{};
 
+  // Clear all cached associated interface proxies as well, since these are
+  // effectively bound to the lifetime of the Channel.
+  remote_route_provider_.reset();
+  RemoveUserData(kRendererInterfaceKeyName);
+
   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 336 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