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 453 matching lines @@
 
 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();
+  RemoveUserData(kRendererInterfaceKeyName);
 
   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)
@@ skipping 535 matching lines @@
 }
 
 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) {
+    holder = new AssociatedInterfaceHolder<mojom::Renderer>;
+
+    // Takes ownership of |holder|.
+    host->SetUserData(kRendererInterfaceKeyName, holder);
+
+    // In tests, GetChannel() is null. We bind the proxy to a dead-end endpoint
+    // so that its outgoing requests are be silently dropped.
+    IPC::ChannelProxy* channel = host->GetChannel();
+    if (channel)
+      channel->GetRemoteAssociatedInterface(&holder->proxy());
+    else
+      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 1589 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