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

mojo/shell/application_manager.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 "mojo/shell/application_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 60 matching lines @@
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void ApplicationManager::Connect(scoped_ptr<ConnectParams> params) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
                        params->target().url().spec());
   DCHECK(params->target().url().is_valid());
 
-  if (params->target().user_id() == mojom::Shell::kUserInherit) {
+  if (params->target().user_id() == mojom::Connector::kUserInherit) {
     ApplicationInstance* source = GetApplicationInstance(params->source());
     Identity target = params->target();
     // TODO(beng): we should CHECK source.
     target.set_user_id(source ? source->identity().user_id()
-                              : mojom::Shell::kUserRoot);
+                              : mojom::Connector::kUserRoot);
     params->set_target(target);
   }
 
   // Connect to an existing matching instance, if possible.
   if (ConnectToExistingInstance(&params))
     return;
 
   std::string url = params->target().url().spec();
   shell_resolver_->ResolveMojoURL(
       url,
@@ skipping 75 matching lines @@
     ScopedHandle channel,
     const String& url,
     mojom::CapabilityFilterPtr filter,
     mojom::PIDReceiverRequest pid_receiver) {
   // We don't call ConnectToClient() here since the instance was created
   // manually by other code, not in response to a Connect() request. The newly
   // created instance is identified by |url| and may be subsequently reached by
   // client code using this identity.
   CapabilityFilter local_filter = filter->filter.To<CapabilityFilter>();
   // TODO(beng): obtain userid from the inbound connection.
-  Identity target_id(url.To<GURL>(), std::string(), mojom::Shell::kUserInherit,
-                     local_filter);
+  Identity target_id(url.To<GURL>(), std::string(),
+                     mojom::Connector::kUserInherit, local_filter);
   mojom::ShellClientRequest request;
   ApplicationInstance* instance = CreateInstance(target_id, &request);
   instance->BindPIDReceiver(std::move(pid_receiver));
   scoped_ptr<NativeRunner> runner =
       native_runner_factory_->Create(base::FilePath());
   runner->InitHost(std::move(channel), std::move(request));
   instance->SetNativeRunner(runner.get());
   native_runners_.push_back(std::move(runner));
 }
 
@@ skipping 22 matching lines @@
   SetLoaderForURL(std::move(loader), url);
 
   ConnectToInterface(this, CreateShellIdentity(), url, &shell_resolver_);
 }
 
 bool ApplicationManager::ConnectToExistingInstance(
     scoped_ptr<ConnectParams>* params) {
   ApplicationInstance* instance = GetApplicationInstance((*params)->target());
   if (!instance) {
     Identity root_identity = (*params)->target();
-    root_identity.set_user_id(mojom::Shell::kUserRoot);
+    root_identity.set_user_id(mojom::Connector::kUserRoot);
     instance = GetApplicationInstance(root_identity);
     if (!instance) return false;
   }
   instance->ConnectToClient(std::move(*params));
   return true;
 }
 
 ApplicationInstance* ApplicationManager::CreateInstance(
     const Identity& target_id,
     mojom::ShellClientRequest* request) {
@@ skipping 136 matching lines @@
   info->qualifier = instance->identity().qualifier();
   if (instance->identity().url().spec() == "mojo://shell/")
     info->pid = base::Process::Current().Pid();
   else
     info->pid = instance->pid();
   return info;
 }
 
 }  // namespace shell
 }  // namespace mojo