Extract a Connector interface from Shell that can be cloned & passed to other threads

mojo/shell/public/cpp/lib/shell_connection.cc

 // Copyright 2014 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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "mojo/shell/public/cpp/connector.h"
 #include "mojo/shell/public/cpp/lib/connection_impl.h"
+#include "mojo/shell/public/cpp/lib/connector_impl.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/cpp/shell_connection.h"
 
 namespace mojo {
 
 namespace {
 
 void DefaultTerminationClosure() {
   if (base::MessageLoop::current() &&
       base::MessageLoop::current()->is_running())
@@ skipping 54 matching lines @@
   ShellConnection* connection_;
   scoped_refptr<base::SingleThreadTaskRunner> app_task_runner_;
 
 #ifndef NDEBUG
   scoped_refptr<base::SingleThreadTaskRunner> clone_task_runner_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(AppRefCountImpl);
 };
 
-
-ShellConnection::ConnectParams::ConnectParams(const std::string& url)
-    : url_(url),
-      filter_(shell::mojom::CapabilityFilter::New()),
-      user_id_(shell::mojom::Shell::kUserInherit) {
-  filter_->filter.SetToEmpty();
-}
-ShellConnection::ConnectParams::~ConnectParams() {}
-
 ////////////////////////////////////////////////////////////////////////////////
 // ShellConnection, public:
 
 ShellConnection::ShellConnection(
     mojo::ShellClient* client,
     InterfaceRequest<shell::mojom::ShellClient> request)
     : ShellConnection(client,
                       std::move(request),
                       base::Bind(&DefaultTerminationClosure)) {}
 
@@ skipping 12 matching lines @@
 
 void ShellConnection::WaitForInitialize() {
   DCHECK(!shell_.is_bound());
   binding_.WaitForIncomingMethodCall();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellConnection, Shell implementation:
 
 scoped_ptr<Connection> ShellConnection::Connect(const std::string& url) {
-  ConnectParams params(url);
-  params.set_filter(CreatePermissiveCapabilityFilter());
-  return Connect(&params);
+  return connector_->Connect(url);
 }
 
-scoped_ptr<Connection> ShellConnection::Connect(ConnectParams* params) {
-  if (!shell_)
-    return nullptr;
-  DCHECK(params);
-  std::string application_url = params->url().spec();
-  // We allow all interfaces on outgoing connections since we are presumably in
-  // a position to know who we're talking to.
-  // TODO(beng): is this a valid assumption or do we need to figure some way to
-  //             filter here too?
-  std::set<std::string> allowed;
-  allowed.insert("*");
-  shell::mojom::InterfaceProviderPtr local_interfaces;
-  shell::mojom::InterfaceProviderRequest local_request =
-      GetProxy(&local_interfaces);
-  shell::mojom::InterfaceProviderPtr remote_interfaces;
-  shell::mojom::InterfaceProviderRequest remote_request =
-      GetProxy(&remote_interfaces);
-  scoped_ptr<internal::ConnectionImpl> registry(new internal::ConnectionImpl(
-      application_url, application_url,
-      shell::mojom::Shell::kInvalidApplicationID, params->user_id(),
-      std::move(remote_interfaces), std::move(local_request), allowed));
-  shell_->Connect(application_url,
-                  params->user_id(),
-                  std::move(remote_request),
-                  std::move(local_interfaces),
-                  params->TakeFilter(),
-                  registry->GetConnectCallback());
-  return std::move(registry);
+scoped_ptr<Connection> ShellConnection::Connect(
+    Connector::ConnectParams* params) {
+  return connector_->Connect(params);
+}
+
+scoped_ptr<Connector> ShellConnection::CloneConnector() const {
+  return connector_->Clone();
 }
 
 void ShellConnection::Quit() {
   // We can't quit immediately, since there could be in-flight requests from the
   // shell. So check with it first.
   if (shell_) {
     quit_requested_ = true;
     shell_->QuitApplication();
   } else {
     QuitNow();
   }
 }
 
 scoped_ptr<AppRefCount> ShellConnection::CreateAppRefCount() {
   AddRef();
   return make_scoped_ptr(
       new AppRefCountImpl(this, base::MessageLoop::current()->task_runner()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellConnection, shell::mojom::ShellClient implementation:
 
 void ShellConnection::Initialize(shell::mojom::ShellPtr shell,
                                  const mojo::String& url,
                                  uint32_t id,
                                  uint32_t user_id) {
   shell_ = std::move(shell);
   shell_.set_connection_error_handler([this]() { OnConnectionError(); });
+
+  shell::mojom::ConnectorPtr connector;
+  shell_->GetConnector(GetProxy(&connector));
+  connector_.reset(new ConnectorImpl(connector.PassInterface()));
+
   client_->Initialize(this, url, id, user_id);
 }
 
 void ShellConnection::AcceptConnection(
     const String& requestor_url,
     uint32_t requestor_id,
     uint32_t requestor_user_id,
     shell::mojom::InterfaceProviderRequest local_interfaces,
     shell::mojom::InterfaceProviderPtr remote_interfaces,
     Array<String> allowed_interfaces,
@@ skipping 64 matching lines @@
 shell::mojom::CapabilityFilterPtr CreatePermissiveCapabilityFilter() {
   shell::mojom::CapabilityFilterPtr filter(
       shell::mojom::CapabilityFilter::New());
   Array<String> all_interfaces;
   all_interfaces.push_back("*");
   filter->filter.insert("*", std::move(all_interfaces));
   return filter;
 }
 
 }  // namespace mojo