Change signature of OnConnect

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 96 matching lines @@
 
   // 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.
-  void GetRemoteInterface(const mojo::String& interface_name,
-                          mojo::ScopedMessagePipeHandle request_handle) {
-    DCHECK(started_);
-    io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&IOThreadContext::GetRemoteInterfaceOnIOThread, this,
-                   interface_name, base::Passed(&request_handle)));
-  }
-
  private:
   friend class base::RefCountedThreadSafe<IOThreadContext>;
 
   ~IOThreadContext() override {}
 
   void StartOnIOThread() {
     // Should bind |io_thread_checker_| to the context's thread.
     DCHECK(io_thread_checker_.CalledOnValidThread());
     service_context_.reset(new shell::ServiceContext(
         this, std::move(pending_service_request_),
         std::move(io_thread_connector_),
         std::move(pending_connector_request_)));
   }
 
   void ShutDownOnIOThread() {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     service_context_.reset();
     factory_bindings_.CloseAllBindings();
   }
 
-  void GetRemoteInterfaceOnIOThread(
-      const mojo::String& interface_name,
-      mojo::ScopedMessagePipeHandle request_handle) {
-    DCHECK(io_thread_checker_.CalledOnValidThread());
-    if (browser_connection_) {
-      browser_connection_->GetRemoteInterfaces()->GetInterface(
-          interface_name, std::move(request_handle));
-    } else {
-      pending_remote_interface_requests_.emplace(interface_name,
-                                                 std::move(request_handle));
-    }
-  }
-
   void OnBrowserConnectionLost() {
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    browser_connection_ = nullptr;
+    has_browser_connection_ = false;
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // shell::Service implementation
 
   void OnStart(const shell::Identity& identity) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     DCHECK(!initialize_handler_.is_null());
 
     InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
     callback_task_runner_->PostTask(FROM_HERE, base::Bind(handler, identity));
   }
 
-  bool OnConnect(shell::Connection* connection) override {
+  bool OnConnect(const shell::Identity& remote_identity,
+                 shell::InterfaceRegistry* registry) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    std::string remote_app = connection->GetRemoteIdentity().name();
+    std::string remote_app = remote_identity.name();
     if (remote_app == "mojo:shell") {
       // Only expose the SCF interface to the shell.
-      connection->AddInterface<shell::mojom::ServiceFactory>(this);
+      registry->AddInterface<shell::mojom::ServiceFactory>(this);
       return true;
     }
 
     bool accept = false;
     for (auto& filter : connection_filters_) {
       accept = accept ||
-        filter->OnConnect(connection, service_context_->connector());
+        filter->OnConnect(remote_identity, registry,
+                          service_context_->connector());
     }
 
-    // Capture the browser connection if possible.
-    if (remote_app == "exe:content_browser" && !browser_connection_) {
-      browser_connection_ = connection;
-      connection->GetInterfaceRegistry()->set_default_binder(
-          default_browser_binder_);
-      connection->SetConnectionLostClosure(
+    if (remote_identity.name() == "exe:content_browser" &&
+        !has_browser_connection_) {
+      has_browser_connection_ = true;
+      registry->set_default_binder(default_browser_binder_);
+      registry->SetConnectionLostClosure(
           base::Bind(&IOThreadContext::OnBrowserConnectionLost, this));
-      shell::InterfaceProvider* remote_interfaces =
-          connection->GetRemoteInterfaces();
-
-      // Flush any pending outgoing interface requests.
-      while (!pending_remote_interface_requests_.empty()) {
-        auto& request = pending_remote_interface_requests_.front();
-        remote_interfaces->GetInterface(
-            request.first, std::move(request.second));
-        pending_remote_interface_requests_.pop();
-      }
       return true;
     }
 
     // If no filters were interested, reject the connection.
     return accept;
   }
 
   bool OnStop() override {
     callback_task_runner_->PostTask(FROM_HERE, stop_callback_);
     return true;
@@ skipping 44 matching lines @@
 
   // Callback to run once Service::OnStart is invoked.
   InitializeCallback initialize_handler_;
 
   // Callback to run when a new Service request is received.
   ServiceFactoryCallback create_service_callback_;
 
   // Callback to run if the service is stopped by the service manager.
   base::Closure stop_callback_;
 
-  // The incoming Connection from the browser process. This is captured the
-  // first time the browser connects to this Service and persists until shutdown
-  // or a connection error is detected. This connection is used to fulfill
-  // remote interface requests from legacy code which does not use
-  // shell::Connector.
-  //
-  // TODO(rockot): Remove this once all child-to-browser interface connections
-  // are made via a Connector rather than directly through an InterfaceProvider
-  // and all interfaces exposed to the browser are exposed via a
-  // ConnectionFilter.
-  shell::Connection* browser_connection_ = nullptr;
-
-  // A queue of remote interface requests destined for the browser, which will
-  // remain pending until an incoming connection is accepted from the browser.
-  //
-  // TODO(rockot): Remove this once all child-to-browser interface connections
-  // are made via a Connector rather than directly through an InterfaceProvider.
-  std::queue<std::pair<mojo::String, mojo::ScopedMessagePipeHandle>>
-      pending_remote_interface_requests_;
+  // Called once a connection has been received from the browser process & the
+  // default binder (below) has been set up.
+  bool has_browser_connection_ = false;
 
   // Default binder callback used for the browser connection's
   // 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_;
@@ skipping 97 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_));
+  // TODO(beng): remove provider parameter.
 }
 
 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);
@@ skipping 39 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