Use a static catalog manifest for the standalone Mash runner

services/service_manager/service_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 "services/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 654 matching lines @@
     return;
 
   // The catalog needs to see the source identity as that of the originating
   // app so it loads the correct store. Since the catalog is itself run as root
   // when this re-enters Connect() it'll be handled by
   // ConnectToExistingInstance().
   mojom::Resolver* resolver = GetResolver(Identity(
       service_manager::mojom::kServiceName, params->target().user_id()));
 
   std::string name = params->target().name();
-  resolver->ResolveMojoName(
+  resolver->ResolveServiceName(
       name,
       base::Bind(&service_manager::ServiceManager::OnGotResolvedName,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
                  base::Passed(&service), !!source_instance, source_instance));
 }
 
 ServiceManager::Instance* ServiceManager::GetExistingInstance(
     const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   Instance* instance = it != identity_to_instance_.end() ? it->second : nullptr;
@@ skipping 127 matching lines @@
 void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
                                        mojom::ServicePtr service,
                                        bool has_source_instance,
                                        base::WeakPtr<Instance> source_instance,
                                        mojom::ResolveResultPtr result) {
   // If this request was originated by a specific Instance and that Instance is
   // no longer around, we ignore this response.
   if (has_source_instance && !source_instance)
     return;
 
+  // If name resolution failed, we drop the connection.
+  if (!result) {
+    LOG(ERROR) << "Failed to resolve service name: " << params->target().name();
+    if (!params->connect_callback().is_null()) {
+      params->connect_callback().Run(
+          mojom::ConnectResult::INVALID_ARGUMENT, "");
+    }
+    return;
+  }
+
   std::string instance_name = params->target().instance();
   if (instance_name == params->target().name() &&
       result->qualifier != result->resolved_name) {
     instance_name = result->qualifier;
   }
   // |result->interface_provider_specs| can be empty when there is no manifest,
   // e.g. for URL types not resolvable by the resolver.
   InterfaceProviderSpec connection_spec = GetPermissiveInterfaceProviderSpec();
   auto it = result->interface_provider_specs.find(
       mojom::kServiceManager_ConnectorSpec);
@@ skipping 108 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager