Cascade shutdown of instances

mojo/shell/shell.h

 // 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.
 
 #ifndef MOJO_SHELL_SHELL_H_
 #define MOJO_SHELL_SHELL_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 69 matching lines @@
   void set_default_loader(scoped_ptr<Loader> loader) {
     default_loader_ = std::move(loader);
   }
 
   // Sets a Loader to be used for a specific name.
   void SetLoaderForName(scoped_ptr<Loader> loader, const std::string& name);
 
  private:
   class Instance;
 
-  using IdentityToInstanceMap = std::map<Identity, Instance*>;
-  using NameToLoaderMap = std::map<std::string, Loader*>;
-  using IdentityToShellClientFactoryMap =
-      std::map<Identity, mojom::ShellClientFactoryPtr>;
-
   // ShellClient:
   bool AcceptConnection(Connection* connection) override;
 
   void InitCatalog(mojom::ShellClientPtr catalog);
 
   // Destroys all Shell-ends of connections established with Applications.
   // Applications connected by this Shell will observe pipe errors and have a
   // chance to shutdown.
   void TerminateShellConnections();
 
@@ skipping 13 matching lines @@
   // running as a different user if one is available that services all users.
   Instance* GetExistingInstance(const Identity& identity) const;
 
   void NotifyPIDAvailable(uint32_t id, base::ProcessId pid);
 
   // Attempt to complete the connection requested by |params| by connecting to
   // an existing instance. If there is an existing instance, |params| is taken,
   // and this function returns true.
   bool ConnectToExistingInstance(scoped_ptr<ConnectParams>* params);
 
-  Instance* CreateInstance(const Identity& target,
+  Instance* CreateInstance(const Identity& source,
+                           const Identity& target,
                            const CapabilitySpec& spec);
 
   // Called from the instance implementing mojom::Shell.
   void AddInstanceListener(mojom::InstanceListenerPtr listener);
 
   void CreateShellClientWithFactory(const Identity& source,
                                     const Identity& shell_client_factory,
                                     const std::string& name,
                                     mojom::ShellClientRequest request);
   // Returns a running ShellClientFactory for |shell_client_factory_identity|.
@@ skipping 22 matching lines @@
 
   // Tries to load |target| with an Loader. Returns true if one was registered
   // and it was loaded, in which case |request| is taken.
   bool LoadWithLoader(const Identity& target,
                       mojom::ShellClientRequest* request);
 
   // Returns the appropriate loader for |name|, or the default loader if there
   // is no loader configured for the name.
   Loader* GetLoaderForName(const std::string& name);
 
+  base::WeakPtr<Shell> GetWeakPtr();
+
   void CleanupRunner(NativeRunner* runner);
 
   // Loader management.
   // Loaders are chosen in the order they are listed here.
-  NameToLoaderMap name_to_loader_;
+  std::map<std::string, Loader*> name_to_loader_;
   scoped_ptr<Loader> default_loader_;
 
-  IdentityToInstanceMap identity_to_instance_;
+  std::map<Identity, Instance*> identity_to_instance_;
 
   // Tracks the names of instances that are allowed to field connection requests
   // from all users.
   std::set<std::string> singletons_;
 
-  IdentityToShellClientFactoryMap shell_client_factories_;
+  std::map<Identity, mojom::ShellClientFactoryPtr> shell_client_factories_;
   // Counter used to assign ids to client factories.
   uint32_t shell_client_factory_id_counter_;
 
   InterfacePtrSet<mojom::InstanceListener> instance_listeners_;
 
   base::Callback<void(const Identity&)> instance_quit_callback_;
   scoped_ptr<NativeRunnerFactory> native_runner_factory_;
   std::vector<scoped_ptr<NativeRunner>> native_runners_;
   scoped_ptr<ShellConnection> shell_connection_;
   base::WeakPtrFactory<Shell> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Shell);
 };
 
 mojom::Connector::ConnectCallback EmptyConnectCallback();
 
 }  // namespace shell
 }  // namespace mojo
 
 #endif  // MOJO_SHELL_SHELL_H_