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 68 matching lines @@
     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.
   void AddConnectionFilter(std::unique_ptr<ConnectionFilter> filter) {
-    DCHECK(!started_);
+    //DCHECK(!started_);

[Ken Rockot(use gerrit already), 2016/07/29 17:09:46]

Remove

     connection_filters_.emplace_back(std::move(filter));
   }
 
+  std::unique_ptr<ConnectionFilter> RemoveConnectionFilter(
+      ConnectionFilter* filter) {
+    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 278 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)

[Ken Rockot(use gerrit already), 2016/07/29 17:09:46]

Why would this be null? Tests?

[Ben Goodger (Google), 2016/07/29 19:35:02]

In the case I've just added. We use the IP from the outgoing connection, not the
dummy passed to this method.

+    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