Add a test for application lifecycle

mojo/services/package_manager/package_manager.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 "mojo/services/package_manager/package_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/strings/string_split.h"
 #include "base/task_runner_util.h"
@@ skipping 25 matching lines @@
   return filter;
 }
 
 ApplicationInfo BuildApplicationInfoFromDictionary(
     const base::DictionaryValue& value) {
   ApplicationInfo info;
   std::string name_string;
   CHECK(value.GetString(ApplicationCatalogStore::kNameKey, &name_string));
   CHECK(mojo::IsValidName(name_string)) << "Invalid Name: " << name_string;
   info.name = name_string;
+  if (value.HasKey(ApplicationCatalogStore::kQualifierKey)) {
+    CHECK(value.GetString(ApplicationCatalogStore::kQualifierKey,
+                          &info.qualifier));
+  } else {
+    info.qualifier = mojo::GetNamePath(name_string);
+  }
   CHECK(value.GetString(ApplicationCatalogStore::kDisplayNameKey,
                         &info.display_name));
   const base::DictionaryValue* capabilities = nullptr;
   CHECK(value.GetDictionary(ApplicationCatalogStore::kCapabilitiesKey,
                             &capabilities));
   info.base_filter = BuildCapabilityFilterFromDictionary(*capabilities);
   return info;
 }
 
 void SerializeEntry(const ApplicationInfo& entry,
@@ skipping 20 matching lines @@
   // TODO(beng): probably want to do more detailed error checking. This should
   //             be done when figuring out if to unblock connection completion.
   return deserializer.Deserialize(&error, &message);
 }
 
 }  // namespace
 
 // static
 const char ApplicationCatalogStore::kNameKey[] = "name";
 // static
+const char ApplicationCatalogStore::kQualifierKey[] = "process-group";
+// static
 const char ApplicationCatalogStore::kDisplayNameKey[] = "display_name";
 // static
 const char ApplicationCatalogStore::kCapabilitiesKey[] = "capabilities";
 
 ApplicationInfo::ApplicationInfo() {}
 ApplicationInfo::ApplicationInfo(const ApplicationInfo& other) = default;
 ApplicationInfo::~ApplicationInfo() {}
 
 PackageManager::PackageManager(base::TaskRunner* blocking_pool,
                                scoped_ptr<ApplicationCatalogStore> catalog)
@@ skipping 54 matching lines @@
 void PackageManager::ResolveProtocolScheme(
     const mojo::String& scheme,
     const ResolveProtocolSchemeCallback& callback) {
   // TODO(beng): implement.
 }
 
 void PackageManager::ResolveMojoName(const mojo::String& mojo_name,
                                      const ResolveMojoNameCallback& callback) {
   std::string resolved_name = mojo_name;
   auto alias_iter = mojo_name_aliases_.find(resolved_name);
-  std::string qualifier;
-  if (alias_iter != mojo_name_aliases_.end()) {
+  if (alias_iter != mojo_name_aliases_.end())
     resolved_name = alias_iter->second.first;
-    qualifier = alias_iter->second.second;
-  } else {
-    qualifier = mojo::GetNamePath(resolved_name);
-  }
 
-  EnsureNameInCatalog(resolved_name, qualifier, callback);
+  std::string qualifier = mojo::GetNamePath(resolved_name);
+  auto qualifier_iter = qualifiers_.find(resolved_name);
+  if (qualifier_iter != qualifiers_.end())
+    qualifier = qualifier_iter->second;
+
+  if (IsNameInCatalog(resolved_name))
+    CompleteResolveMojoName(resolved_name, qualifier, callback);
+  else
+    AddNameToCatalog(resolved_name, callback);
 }
 
 void PackageManager::GetEntries(
     mojo::Array<mojo::String> names,
     const GetEntriesCallback& callback) {
   mojo::Map<mojo::String, mojom::CatalogEntryPtr> entries;
   std::vector<mojo::String> names_vec = names.PassStorage();
   for (const std::string& name : names_vec) {
     if (catalog_.find(name) == catalog_.end())
       continue;
@@ skipping 38 matching lines @@
     filter->filter.insert(entry.first, std::move(interfaces));
   }
   callback.Run(resolved_name, qualifier, std::move(filter),
                file_url.spec());
 }
 
 bool PackageManager::IsNameInCatalog(const std::string& name) const {
   return catalog_.find(name) != catalog_.end();
 }
 
-void PackageManager::EnsureNameInCatalog(
+void PackageManager::AddNameToCatalog(
     const std::string& name,
-    const std::string& qualifier,
     const ResolveMojoNameCallback& callback) {
-  if (IsNameInCatalog(name)) {
-    CompleteResolveMojoName(name, qualifier, callback);
-    return;
-  }
-
   GURL manifest_url = GetManifestURL(name);
   if (manifest_url.is_empty()) {
     // The name is of some form that can't be resolved to a manifest (e.g. some
     // scheme used for tests). Just pass it back to the caller so it can be
     // loaded with a custom loader.
-    callback.Run(name, name, nullptr, nullptr);
+    callback.Run(name, mojo::GetNamePath(name), nullptr, nullptr);
     return;
   }
 
   std::string type = mojo::GetNameType(name);
   CHECK(type == "mojo" || type == "exe");
   base::FilePath manifest_path;
   CHECK(net::FileURLToFilePath(manifest_url, &manifest_path));
   base::PostTaskAndReplyWithResult(
       blocking_pool_, FROM_HERE, base::Bind(&ReadManifest, manifest_path),
       base::Bind(&PackageManager::OnReadManifest, weak_factory_.GetWeakPtr(),
-                 name, qualifier, callback));
+                 name, callback));
 }
 
 void PackageManager::DeserializeCatalog() {
   if (!catalog_store_)
     return;
   const base::ListValue* catalog = catalog_store_->GetStore();
   CHECK(catalog);
   // TODO(sky): make this handle aliases.
   for (auto it = catalog->begin(); it != catalog->end(); ++it) {
     const base::DictionaryValue* dictionary = nullptr;
@@ skipping 23 matching lines @@
     catalog_[info.name] = info;
 
     if (dictionary->HasKey("applications")) {
       const base::ListValue* applications = nullptr;
       dictionary->GetList("applications", &applications);
       for (size_t i = 0; i < applications->GetSize(); ++i) {
         const base::DictionaryValue* child = nullptr;
         applications->GetDictionary(i, &child);
         const ApplicationInfo& child_info = DeserializeApplication(child);
         mojo_name_aliases_[child_info.name] =
-            std::make_pair(info.name, mojo::GetNamePath(child_info.name));
+            std::make_pair(info.name, child_info.qualifier);
       }
     }
+    qualifiers_[info.name] = info.qualifier;
   }
   return catalog_[info.name];
 }
 
 GURL PackageManager::GetManifestURL(const std::string& name) {
   // TODO(beng): think more about how this should be done for exe targets.
   std::string type = mojo::GetNameType(name);
   std::string path = mojo::GetNamePath(name);
   if (type == "mojo")
     return system_package_dir_.Resolve(path + "/manifest.json");
   else if (type == "exe")
     return system_package_dir_.Resolve(path + "_manifest.json");
   return GURL();
 }
 
 // static
 void PackageManager::OnReadManifest(base::WeakPtr<PackageManager> pm,
                                     const std::string& name,
-                                    const std::string& qualifier,
                                     const ResolveMojoNameCallback& callback,
                                     scoped_ptr<base::Value> manifest) {
   if (!pm) {
     // The PackageManager was destroyed, we're likely in shutdown. Run the
     // callback so we don't trigger a DCHECK.
-    callback.Run(name, name, nullptr, nullptr);
+    callback.Run(name, mojo::GetNamePath(name), nullptr, nullptr);
     return;
   }
-  pm->OnReadManifestImpl(name, qualifier, callback, std::move(manifest));
+  pm->OnReadManifestImpl(name, callback, std::move(manifest));
 }
 
 void PackageManager::OnReadManifestImpl(const std::string& name,
-                                        const std::string& qualifier,
                                         const ResolveMojoNameCallback& callback,
                                         scoped_ptr<base::Value> manifest) {
   if (manifest) {
     base::DictionaryValue* dictionary = nullptr;
     CHECK(manifest->GetAsDictionary(&dictionary));
     DeserializeApplication(dictionary);
   } else {
     ApplicationInfo info;
     info.name = name;
     info.display_name = name;
     catalog_[info.name] = info;
+    qualifiers_[info.name] = mojo::GetNamePath(name);
   }
   SerializeCatalog();
+
+  auto qualifier_iter = qualifiers_.find(name);
+  DCHECK(qualifier_iter != qualifiers_.end());
+  std::string qualifier = qualifier_iter->second;
   CompleteResolveMojoName(name, qualifier, callback);
 }
 
 }  // namespace package_manager