Renderers should obtain browser InterfaceProvider by connecting to browser

content/common/mojo/mojo_shell_connection_impl.cc

 // Copyright 2016 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/common/mojo/mojo_shell_connection_impl.h"
 
 #include <queue>
 #include <utility>
 #include <vector>
 
@@ skipping 66 matching lines @@
   // Start()). Must be called before IO thread shutdown.
   void ShutDown() {
     if (!started_)
       return;
 
     bool posted = io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&IOThreadContext::ShutDownOnIOThread, this));
     DCHECK(posted);
   }
 
-  // Safe to call any time before Start() is called.
+  // Safe to call any time before a message is received from a process.
+  // i.e. can be called when starting the process but not afterwards.
   void AddConnectionFilter(std::unique_ptr<ConnectionFilter> filter) {
-    DCHECK(!started_);
+    base::AutoLock lock(lock_);
     connection_filters_.emplace_back(std::move(filter));
   }
 
+  std::unique_ptr<ConnectionFilter> RemoveConnectionFilter(
+      ConnectionFilter* filter) {
+    base::AutoLock lock(lock_);
+    for (auto it = connection_filters_.begin(); it != connection_filters_.end();
+         ++it) {
+      if (it->get() == filter) {
+        std::unique_ptr<ConnectionFilter> taken = std::move(*it);
+        connection_filters_.erase(it);
+        return taken;
+      }
+    }
+    return nullptr;
+  }
+
   // Safe to call any time before Start() is called.
   void SetDefaultBinderForBrowserConnection(
       const shell::InterfaceRegistry::Binder& binder) {
     DCHECK(!started_);
     default_browser_binder_ = base::Bind(
         &IOThreadContext::CallBinderOnTaskRunner,
         base::ThreadTaskRunnerHandle::Get(), binder);
   }
 
   // Safe to call any time after Start() is called.
@@ skipping 175 matching lines @@
   // InterfaceRegistry.
   //
   // TODO(rockot): Remove this once all interfaces exposed to the browser are
   // exposed via a ConnectionFilter.
   shell::InterfaceRegistry::Binder default_browser_binder_;
 
   std::unique_ptr<shell::ServiceContext> service_context_;
   mojo::BindingSet<shell::mojom::ServiceFactory> factory_bindings_;
   std::vector<std::unique_ptr<ConnectionFilter>> connection_filters_;
 
+  base::Lock lock_;
+
   DISALLOW_COPY_AND_ASSIGN(IOThreadContext);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // MojoShellConnection, public:
 
 // static
 void MojoShellConnection::SetForProcess(
     std::unique_ptr<MojoShellConnection> connection) {
   DCHECK(!g_connection_for_process.Get());
@@ skipping 83 matching lines @@
 
 void MojoShellConnectionImpl::SetupInterfaceRequestProxies(
     shell::InterfaceRegistry* registry,
     shell::InterfaceProvider* provider) {
   // It's safe to bind |registry| as a raw pointer because the caller must
   // guarantee that it outlives |this|, and |this| is bound as a weak ptr here.
   context_->SetDefaultBinderForBrowserConnection(
       base::Bind(&MojoShellConnectionImpl::GetInterface,
                  weak_factory_.GetWeakPtr(), registry));
 
+  if (!provider)
+    return;
+
   // Forward all remote interface requests on |provider| to our IO-thread
   // context. This will ensure they're forwarded to the provider on the
   // incoming browser connection.
-  provider->Forward(base::Bind(&IOThreadContext::GetRemoteInterface, context_));
+  provider->Forward(base::Bind(&IOThreadContext::GetRemoteInterface,
+                                context_));
 }
 
 void MojoShellConnectionImpl::AddConnectionFilter(
     std::unique_ptr<ConnectionFilter> filter) {
   context_->AddConnectionFilter(std::move(filter));
 }
 
+std::unique_ptr<ConnectionFilter>
+MojoShellConnectionImpl::RemoveConnectionFilter(ConnectionFilter* filter) {
+  return context_->RemoveConnectionFilter(filter);
+}
+
 void MojoShellConnectionImpl::AddEmbeddedService(
     const std::string& name,
     const MojoApplicationInfo& info) {
   std::unique_ptr<EmbeddedApplicationRunner> app(
       new EmbeddedApplicationRunner(name, info));
   AddServiceRequestHandler(
       name, base::Bind(&EmbeddedApplicationRunner::BindServiceRequest,
                        base::Unretained(app.get())));
   auto result = embedded_apps_.insert(std::make_pair(name, std::move(app)));
   DCHECK(result.second);
@@ skipping 27 matching lines @@
 }
 
 void MojoShellConnectionImpl::GetInterface(
     shell::mojom::InterfaceProvider* provider,
     const mojo::String& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   provider->GetInterface(interface_name, std::move(request_handle));
 }
 
 }  // namespace content