Renderers should obtain browser InterfaceProvider by connecting to browser

content/child/child_thread_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/child/child_thread_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 35 matching lines @@
 #include "content/child/push_messaging/push_dispatcher.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/quota_message_filter.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/service_worker/service_worker_message_filter.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/websocket_dispatcher.h"
 #include "content/child/websocket_message_filter.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/in_process_child_thread_params.h"
+#include "content/common/mojo/constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/mojo_shell_connection.h"
 #include "ipc/attachment_broker.h"
 #include "ipc/attachment_broker_unprivileged.h"
 #include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_platform_file.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/named_platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
+#include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "services/shell/runner/common/client_util.h"
 
 #if defined(OS_POSIX)
 #include "base/posix/global_descriptors.h"
 #include "content/public/common/content_descriptors.h"
 #endif
 
 using tracked_objects::ThreadData;
@@ skipping 178 matching lines @@
 
 ChildThread* ChildThread::Get() {
   return ChildThreadImpl::current();
 }
 
 ChildThreadImpl::Options::Options()
     : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID)),
       use_mojo_channel(base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoChannelToken)),
-      auto_start_mojo_shell_connection(true) {
+      auto_start_mojo_shell_connection(true),
+      connect_to_browser(false) {
 }
 
 ChildThreadImpl::Options::Options(const Options& other) = default;
 
 ChildThreadImpl::Options::~Options() {
 }
 
 ChildThreadImpl::Options::Builder::Builder() {
 }
 
@@ skipping 14 matching lines @@
 }
 
 ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::AutoStartMojoShellConnection(
     bool auto_start) {
   options_.auto_start_mojo_shell_connection = auto_start;
   return *this;
 }
 
 ChildThreadImpl::Options::Builder&
+ChildThreadImpl::Options::Builder::ConnectToBrowser(
+  bool connect_to_browser) {
+  options_.connect_to_browser = connect_to_browser;
+  return *this;
+}
+
+ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::WithChannelName(
     const std::string& channel_name) {
   options_.channel_name = channel_name;
   return *this;
 }
 
 ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::AddStartupFilter(
     IPC::MessageFilter* filter) {
   options_.startup_filters.push_back(filter);
@@ skipping 111 matching lines @@
     mojo_application_token = options.in_process_application_token;
   }
   if (!mojo_application_token.empty()) {
     mojo::ScopedMessagePipeHandle handle =
         mojo::edk::CreateChildMessagePipe(mojo_application_token);
     DCHECK(handle.is_valid());
     mojo_shell_connection_ = MojoShellConnection::Create(
         mojo::MakeRequest<shell::mojom::Service>(std::move(handle)),
         GetIOTaskRunner());
 
+    // When connect_to_browser is true, we obtain interfaces from the browser
+    // process by connecting to it, rather than from the incoming interface
+    // provider. Exposed interfaces are subject to manifest capability spec.
+    shell::InterfaceProvider* remote_interfaces = nullptr;
+    if (options.connect_to_browser) {
+      browser_connection_ = mojo_shell_connection_->GetConnector()->Connect(
+          kBrowserMojoApplicationName);
+    } else {
+      remote_interfaces = GetRemoteInterfaces();
+    }
+
     // TODO(rockot): Remove this once all child-to-browser interface connections
     // are made via a Connector rather than directly through an
     // InterfaceProvider, and all exposed interfaces are exposed via a
     // ConnectionFilter.
     mojo_shell_connection_->SetupInterfaceRequestProxies(
-        GetInterfaceRegistry(), GetRemoteInterfaces());
+        GetInterfaceRegistry(), remote_interfaces);
 
     if (options.auto_start_mojo_shell_connection)
       StartMojoShellConnection();
   }
 
   sync_message_filter_ = channel_->CreateSyncMessageFilter();
   thread_safe_sender_ = new ThreadSafeSender(
       message_loop_->task_runner(), sync_message_filter_.get());
 
   resource_dispatcher_.reset(new ResourceDispatcher(
@@ skipping 168 matching lines @@
   return mojo_shell_connection_.get();
 }
 
 shell::InterfaceRegistry* ChildThreadImpl::GetInterfaceRegistry() {
   if (!interface_registry_.get())
     interface_registry_.reset(new shell::InterfaceRegistry(nullptr));
   return interface_registry_.get();
 }
 
 shell::InterfaceProvider* ChildThreadImpl::GetRemoteInterfaces() {
+  if (browser_connection_)
+    return browser_connection_->GetRemoteInterfaces();
+
   if (!remote_interfaces_.get())
     remote_interfaces_.reset(new shell::InterfaceProvider);
   return remote_interfaces_.get();
 }
 
 IPC::MessageRouter* ChildThreadImpl::GetRouter() {
   DCHECK(message_loop_->task_runner()->BelongsToCurrentThread());
   return &router_;
 }
 
@@ skipping 147 matching lines @@
 void ChildThreadImpl::EnsureConnected() {
   VLOG(0) << "ChildThreadImpl::EnsureConnected()";
   base::Process::Current().Terminate(0, false);
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content