Add a test for application lifecycle

mojo/services/package_manager/package_manager.h

 // 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.
 
 #ifndef MOJO_SERVICES_PACKAGE_MANAGER_PACKAGE_MANAGER_H_
 #define MOJO_SERVICES_PACKAGE_MANAGER_PACKAGE_MANAGER_H_
 
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
@@ skipping 13 matching lines @@
 // more details.
 using CapabilityFilter = std::map<std::string, AllowedInterfaces>;
 
 // Static information about an application package known to the PackageManager.
 struct ApplicationInfo {
   ApplicationInfo();
   ApplicationInfo(const ApplicationInfo& other);
   ~ApplicationInfo();
 
   std::string name;
+  std::string qualifier;
   std::string display_name;
   CapabilityFilter base_filter;
 };
 
 // Implemented by an object that provides storage for the application catalog
 // (e.g. in Chrome, preferences). The PackageManagerImpl is the canonical owner
 // of the contents of the store, so no one else must modify its contents.
 class ApplicationCatalogStore {
  public:
   // Value is a string.
   static const char kNameKey[];
   // Value is a string.
+  static const char kQualifierKey[];
+  // Value is a string.
   static const char kDisplayNameKey[];
   // Value is a dictionary that maps from the filter to a list of string
   // interfaces.
   static const char kCapabilitiesKey[];
 
   virtual ~ApplicationCatalogStore() {}
 
   // Called during initialization to construct the PackageManagerImpl's catalog.
   // Returns a serialized list of the apps. Each entry in the returned list
   // corresponds to an app (as a dictionary). Each dictionary has a name,
@@ skipping 60 matching lines @@
 
   // Completes resolving a Mojo name from the Shell after the resolved name has
   // been added to the catalog and the manifest read.
   void CompleteResolveMojoName(const std::string& resolved_name,
                                const std::string& qualifier,
                                const ResolveMojoNameCallback& callback);
 
   bool IsNameInCatalog(const std::string& name) const;
 
   // Called from ResolveMojoName().
-  // If |name| is not in the catalog, attempts to load a manifest for it.
-  void EnsureNameInCatalog(const std::string& name,
-                           const std::string& qualifier,
-                           const ResolveMojoNameCallback& callback);
+  // Attempts to load a manifest for |name|, reads it and adds its metadata to
+  // the catalog.
+  void AddNameToCatalog(const std::string& name,
+                        const ResolveMojoNameCallback& callback);
 
   // Populate/serialize the catalog from/to the supplied store.
   void DeserializeCatalog();
   void SerializeCatalog();
 
   // Construct a catalog entry from |dictionary|.
   const ApplicationInfo& DeserializeApplication(
       const base::DictionaryValue* dictionary);
 
   GURL GetManifestURL(const std::string& name);
 
   // Called once the manifest has been read. |pm| may be null at this point,
   // but |callback| must be run.
   static void OnReadManifest(base::WeakPtr<PackageManager> pm,
                              const std::string& name,
-                             const std::string& qualifier,
                              const ResolveMojoNameCallback& callback,
                              scoped_ptr<base::Value> manifest);
 
   // Called once the manifest is read and |this| hasn't been deleted.
   void OnReadManifestImpl(const std::string& name,
-                          const std::string& qualifier,
                           const ResolveMojoNameCallback& callback,
                           scoped_ptr<base::Value> manifest);
 
   base::TaskRunner* blocking_pool_;
   GURL system_package_dir_;
 
   mojo::BindingSet<mojom::Resolver> resolver_bindings_;
   mojo::BindingSet<mojom::ShellResolver> shell_resolver_bindings_;
   mojo::BindingSet<mojom::Catalog> catalog_bindings_;
 
   scoped_ptr<ApplicationCatalogStore> catalog_store_;
   std::map<std::string, ApplicationInfo> catalog_;
 
   // Used when an app handles multiple names. Maps from app (as name) to name of
   // app that is responsible for handling it. The value is a pair of the name of
   // the handler along with a qualifier.
   MojoNameAliasMap mojo_name_aliases_;
 
+  std::map<std::string, std::string> qualifiers_;
+
   base::WeakPtrFactory<PackageManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PackageManager);
 };
 
 }  // namespace package_manager
 
 #endif  // MOJO_SERVICES_PACKAGE_MANAGER_PACKAGE_MANAGER_H_