Rename mojo_application GN templates to service*

services/catalog/reader.cc

 // Copyright 2016 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/catalog/reader.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 18 matching lines @@
   if (type == shell::kNameType_Mojo) {
     return package_dir.AppendASCII(kMojoApplicationsDirName).AppendASCII(
         path + "/manifest.json");
   }
   if (type == shell::kNameType_Exe)
     return package_dir.AppendASCII(path + "_manifest.json");
   return base::FilePath();
 }
 
 
-base::FilePath GetPackagePath(const base::FilePath& package_dir,
-                              const std::string& name) {
+base::FilePath GetExecutablePath(const base::FilePath& package_dir,
+                                 const std::string& name) {
   std::string type = shell::GetNameType(name);
   if (type == shell::kNameType_Mojo) {
     // It's still a mojo: URL, use the default mapping scheme.
     const std::string host = shell::GetNamePath(name);
-    return package_dir.AppendASCII(host + "/" + host + ".mojo");
+    return package_dir.AppendASCII(host + "/" + host + ".library");
   }
   if (type == shell::kNameType_Exe) {
 #if defined OS_WIN
     std::string extension = ".exe";
 #else
     std::string extension;
 #endif
     return package_dir.AppendASCII(shell::GetNamePath(name) + extension);
   }
   return base::FilePath();
 }
 
 std::unique_ptr<Entry> ProcessManifest(
     std::unique_ptr<base::Value> manifest_root,
     const base::FilePath& package_dir) {
   // Manifest was malformed or did not exist.
   if (!manifest_root)
     return nullptr;
 
   const base::DictionaryValue* dictionary = nullptr;
   if (!manifest_root->GetAsDictionary(&dictionary))
     return nullptr;
 
   std::unique_ptr<Entry> entry = Entry::Deserialize(*dictionary);
   if (!entry)
     return nullptr;
-  entry->set_path(GetPackagePath(package_dir, entry->name()));
+  entry->set_path(GetExecutablePath(package_dir, entry->name()));
   return entry;
 }
 
 std::unique_ptr<Entry> CreateEntryForManifestAt(
     const base::FilePath& manifest_path,
     const base::FilePath& package_dir) {
   JSONFileValueDeserializer deserializer(manifest_path);
   int error = 0;
   std::string message;
 
@@ skipping 16 matching lines @@
       break;
     base::FilePath manifest_path = path.AppendASCII("manifest.json");
     std::unique_ptr<Entry> entry =
         CreateEntryForManifestAt(manifest_path, package_dir);
     if (!entry)
       continue;
 
     // Skip over subdirs that contain only manifests, they're artifacts of the
     // build (e.g. for applications that are packaged into others) and are not
     // valid standalone packages.
-    base::FilePath package_path = GetPackagePath(package_dir, entry->name());
+    base::FilePath package_path = GetExecutablePath(package_dir, entry->name());
     if (entry->name() != "mojo:shell" && entry->name() != "mojo:catalog" &&
         !base::PathExists(package_path)) {
       continue;
     }
 
     original_thread_task_runner->PostTask(
         FROM_HERE,
         base::Bind(read_manifest_callback, base::Passed(&entry)));
   }
 
   original_thread_task_runner->PostTask(FROM_HERE, read_complete_closure);
 }
 
 std::unique_ptr<Entry> ReadManifest(const base::FilePath& package_dir,
                                     const std::string& mojo_name) {
   std::unique_ptr<Entry> entry = CreateEntryForManifestAt(
       GetManifestPath(package_dir, mojo_name), package_dir);
   if (!entry) {
     entry.reset(new Entry(mojo_name));
-    entry->set_path(GetPackagePath(
+    entry->set_path(GetExecutablePath(
         package_dir.AppendASCII(kMojoApplicationsDirName), mojo_name));
   }
   return entry;
 }
 
 void AddEntryToCache(EntryCache* cache, std::unique_ptr<Entry> entry) {
-  for (auto* child : entry->applications())
+  for (auto* child : entry->services())
     AddEntryToCache(cache, base::WrapUnique(child));
   (*cache)[entry->name()] = std::move(entry);
 }
 
 void DoNothing(shell::mojom::ResolveResultPtr) {}
 
 }  // namespace
 
 // A sequenced task runner is used to guarantee requests are serviced in the
 // order requested. To do otherwise means we may run callbacks in an
@@ skipping 60 matching lines @@
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback,
     std::unique_ptr<Entry> entry) {
   shell::mojom::ResolveResultPtr result =
       shell::mojom::ResolveResult::From(*entry);
   AddEntryToCache(cache, std::move(entry));
   entry_created_callback.Run(std::move(result));
 }
 
 }  // namespace catalog