Simplify resolve.

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 23 matching lines @@
 namespace mojo {
 namespace shell {
 namespace {
 const char kCatalogName[] = "mojo:catalog";
 const char kShellName[] = "mojo:shell";
 const char kCapabilityClass_UserID[] = "user_id";
 const char kCapabilityClass_ClientProcess[] = "client_process";
 const char kCapabilityClass_InstanceName[] = "instance_name";
 const char kCapabilityClass_AllUsers[] = "all_users";
 
-void EmptyResolverCallback(const String& resolved_name,
-                           const String& resolved_instance,
-                           mojom::CapabilitySpecPtr capabilities,
-                           const String& file_url) {}
+void EmptyResolverCallback(mojom::ResolveResultPtr result) {}
 
 }
 
 Identity CreateShellIdentity() {
   return Identity(kShellName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
   return Identity(kCatalogName, mojom::kRootUserID);
 }
@@ skipping 618 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(mojom::ShellResolverPtr resolver,
                               scoped_ptr<ConnectParams> params,
                               mojom::ShellClientPtr client,
-                              const String& resolved_name,
-                              const String& resolved_instance,
-                              mojom::CapabilitySpecPtr capabilities_ptr,
-                              const String& file_url) {
+                              mojom::ResolveResultPtr result) {
   std::string instance_name = params->target().instance();
   if (instance_name == GetNamePath(params->target().name()) &&
-      resolved_instance != GetNamePath(resolved_name)) {
-    instance_name = resolved_instance;
+      result->qualifier != GetNamePath(result->resolved_name)) {
+    instance_name = result->qualifier;
   }
   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>();
+  if (!result->capabilities.is_null())
+    capabilities = result->capabilities.To<CapabilitySpec>();
 
   // Clients that request "all_users" class from the shell are allowed to
   // field connection requests from any user. They also run with a synthetic
   // user id generated here. The user id provided via Connect() is ignored.
   if (HasClass(capabilities, kCapabilityClass_AllUsers)) {
     singletons_.insert(target.name());
     target.set_user_id(base::GenerateGUID());
   }
 
   mojom::ClientProcessConnectionPtr client_process_connection =
@@ skipping 10 matching lines @@
     // Likewise if a ClientProcessConnection was given via Connect(), it
     // provides the ShellClient proxy to use.
     instance->StartWithClientProcessConnection(
         std::move(client_process_connection));
   } else {
     // Otherwise we create a new ShellClient pipe.
     mojom::ShellClientRequest request = GetProxy(&client);
     if (LoadWithLoader(target, &request)) {
       instance->StartWithClient(std::move(client));
     } else {
-      CHECK(!file_url.is_null() && !capabilities_ptr.is_null());
+      CHECK(!result->package_url.is_null() && !result->capabilities.is_null());
 
-      if (target.name() != resolved_name) {
+      if (target.name() != result->resolved_name) {
         instance->StartWithClient(std::move(client));
-        CreateShellClientWithFactory(
-            source, Identity(resolved_name, target.user_id(), instance_name),
-            target.name(), std::move(request));
+        Identity factory(result->resolved_name, target.user_id(),
+                         instance_name);
+        CreateShellClientWithFactory(source, factory, target.name(),
+                                     std::move(request));
       } else {
-        instance->StartWithFilePath(util::UrlToFilePath(file_url.To<GURL>()));
+        instance->StartWithFilePath(
+            util::UrlToFilePath(result->package_url.To<GURL>()));
       }
     }
   }
 
   // Now that the instance has a ShellClient, we can connect to it.
   instance->ConnectToClient(std::move(params));
 }
 
 bool Shell::LoadWithLoader(const Identity& target,
                            mojom::ShellClientRequest* request) {
@@ skipping 19 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