Use chrome manifest with embedded shell

mojo/shell/shell.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/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 421 matching lines @@
   for (auto& runner : native_runners_)
     runner.reset();
 }
 
 void Shell::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void Shell::Connect(scoped_ptr<ConnectParams> params) {
-  TRACE_EVENT_INSTANT1("mojo_shell", "Shell::Connect",
-                       TRACE_EVENT_SCOPE_THREAD, "original_name",
-                       params->target().name());
-  DCHECK(IsValidName(params->target().name()));
-  DCHECK(base::IsValidGUID(params->target().user_id()));
-  DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
-
-  // Connect to an existing matching instance, if possible.
-  if (ConnectToExistingInstance(&params))
-    return;
-
-  std::string name = params->target().name();
-  shell_resolver_->ResolveMojoName(
-      name,
-      base::Bind(&Shell::OnGotResolvedName,
-                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&params)));
+  Connect(std::move(params), nullptr);
 }
 
 mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
-  DCHECK(!embedder_instance_);
+  scoped_ptr<ConnectParams> params(new ConnectParams);
 
-  Identity target(name, mojom::kRootUserID);
-  DCHECK(!GetExistingInstance(target));
+  Identity embedder_identity(name, mojom::kRootUserID);
+  params->set_source(embedder_identity);
+  params->set_target(embedder_identity);
 
   mojom::ShellClientPtr client;
   mojom::ShellClientRequest request = GetProxy(&client);
-  embedder_instance_ =
-      CreateInstance(target, GetPermissiveCapabilities(), std::move(client));
-  DCHECK(embedder_instance_);
+  Connect(std::move(params), std::move(client));
 
   return request;
 }
 
 void Shell::SetLoaderForName(scoped_ptr<Loader> loader,
                              const std::string& name) {
   NameToLoaderMap::iterator it = name_to_loader_.find(name);
   if (it != name_to_loader_.end())
     delete it->second;
   name_to_loader_[name] = loader.release();
@@ skipping 46 matching lines @@
   int id = instance->id();
   delete it->second;
   identity_to_instance_.erase(it);
   instance_listeners_.ForAllPtrs([this, id](mojom::InstanceListener* listener) {
                                    listener->InstanceDestroyed(id);
                                  });
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
+void Shell::Connect(scoped_ptr<ConnectParams> params,
+                    mojom::ShellClientPtr client) {
+  TRACE_EVENT_INSTANT1("mojo_shell", "Shell::Connect",
+                       TRACE_EVENT_SCOPE_THREAD, "original_name",
+                       params->target().name());
+  DCHECK(IsValidName(params->target().name()));
+  DCHECK(base::IsValidGUID(params->target().user_id()));
+  DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
+  DCHECK(!client.is_bound() || !identity_to_instance_.count(params->target()));
+
+  // Connect to an existing matching instance, if possible.
+  if (!client.is_bound() && ConnectToExistingInstance(&params))
+    return;
+
+  std::string name = params->target().name();
+  shell_resolver_->ResolveMojoName(
+      name,
+      base::Bind(&Shell::OnGotResolvedName,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
+                 base::Passed(&client)));
+}
+
 Shell::Instance* Shell::GetExistingInstance(const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   return it != identity_to_instance_.end() ? it->second : nullptr;
 }
 
 Shell::Instance* Shell::GetExistingOrRootInstance(
     const Identity& identity) const {
   Instance* instance = GetExistingInstance(identity);
   if (!instance) {
     Identity root_identity = identity;
@@ skipping 72 matching lines @@
 }
 
 void Shell::OnShellClientFactoryLost(const Identity& which) {
   // Remove the mapping.
   auto it = shell_client_factories_.find(which);
   DCHECK(it != shell_client_factories_.end());
   shell_client_factories_.erase(it);
 }
 
 void Shell::OnGotResolvedName(scoped_ptr<ConnectParams> params,
+                              mojom::ShellClientPtr client,
                               const String& resolved_name,
                               const String& resolved_instance,
                               mojom::CapabilitySpecPtr capabilities_ptr,
                               const String& file_url) {
   std::string instance_name = params->target().instance();
   if (instance_name == GetNamePath(params->target().name()) &&
       resolved_instance != GetNamePath(resolved_name)) {
     instance_name = resolved_instance;
   }
   Identity target(params->target().name(), params->target().user_id(),
                   instance_name);
   params->set_target(target);
 
   // It's possible that when this manifest request was issued, another one was
   // already in-progress and completed by the time this one did, and so the
   // requested application may already be running.
   if (ConnectToExistingInstance(&params))
     return;
 
   Identity source = params->source();
   // |capabilities_ptr| can be null when there is no manifest, e.g. for URL
   // types not resolvable by the resolver.
   CapabilitySpec capabilities = GetPermissiveCapabilities();
   if (!capabilities_ptr.is_null())
     capabilities = capabilities_ptr.To<CapabilitySpec>();
 
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
-  mojom::ShellClientPtr client;
-  mojom::ShellClientRequest request = GetProxy(&client);
+
+  mojom::ShellClientRequest request;
+  if (!client.is_bound())
+    request = GetProxy(&client);
+
   Instance* instance = CreateInstance(target, capabilities, std::move(client));
   instance->ConnectToClient(std::move(params));
 
-  if (LoadWithLoader(target, &request))
+  // If a ShellClientPtr was provided, there's no more work to do: someone
+  // is already holding a corresponding ShellClientRequest.
+  if (!request.is_pending())
+    return;
+
+  if (client_process_connection.is_null() && LoadWithLoader(target, &request))
     return;
 
   CHECK(!file_url.is_null() && !capabilities_ptr.is_null());
 
   if (target.name() != resolved_name) {
     // In cases where a package alias is resolved, we have to use the instance
     // from the original request rather than for the package itself, which will
     // always be the same.
     CreateShellClient(
         source, Identity(resolved_name, target.user_id(), instance_name),
@@ skipping 31 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo