Cascade shutdown of instances

mojo/shell/shell.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 "mojo/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 111 matching lines @@
       allow_any_application_(capability_spec.required.count("*") == 1),
       pid_receiver_binding_(this),
       weak_factory_(this) {
     if (identity_.name() == kShellName ||
         shell_->GetLoaderForName(identity_.name())) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
-  ~Instance() override {}
-
-  void OnShellClientLost() {
-    shell_client_.reset();
-    OnConnectionLost();
+  ~Instance() override {
+    if (parent_)
+      parent_->RemoveChild(this);
+    // |children_| will be modified during destruction.
+    std::set<Instance*> children = children_;
+    for (auto child : children)
+      shell_->OnInstanceError(child);
   }
 
-  void OnConnectionLost() {
-    // Any time a Connector is lost or we lose the ShellClient connection, it
-    // may have been the last pipe using this Instance. If so, clean up.
-    if (connectors_.empty() && !shell_client_) {
-      // Deletes |this|.
-      shell_->OnInstanceError(this);
-    }
+  Instance* parent() { return parent_; }
+  void AddChild(Instance* child) {
+    children_.insert(child);
+    child->parent_ = this;
   }
-
-  void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
-    if (connector_request.is_pending()) {
-      connectors_.AddBinding(this, std::move(connector_request));
-      connectors_.set_connection_error_handler(
-          base::Bind(&Instance::OnConnectionLost, base::Unretained(this)));
-    }
+  void RemoveChild(Instance* child) {
+    auto it = children_.find(child);
+    DCHECK(it != children_.end());
+    children_.erase(it);
+    child->parent_ = nullptr;
   }
 
   void ConnectToClient(scoped_ptr<ConnectParams> params) {
     CHECK(shell_client_.is_bound());
     params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                    identity_.user_id(), id_);
     uint32_t source_id = mojom::kInvalidInstanceID;
     CapabilityRequest spec;
     spec.interfaces.insert("*");
     Instance* source = shell_->GetExistingInstance(params->source());
@@ skipping 213 matching lines @@
     ++id;
     CHECK_NE(mojom::kInvalidInstanceID, id);
     return id;
   }
 
   void PIDAvailable(base::ProcessId pid) {
     pid_ = pid;
     shell_->NotifyPIDAvailable(id_, pid_);
   }
 
+  void OnShellClientLost() {
+    shell_client_.reset();
+    OnConnectionLost();
+  }
+
+  void OnConnectionLost() {
+    // Any time a Connector is lost or we lose the ShellClient connection, it
+    // may have been the last pipe using this Instance. If so, clean up.
+    if (connectors_.empty() && !shell_client_) {
+      // Deletes |this|.
+      shell_->OnInstanceError(this);
+    }
+  }
+
+  void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
+    if (connector_request.is_pending()) {
+      connectors_.AddBinding(this, std::move(connector_request));
+      connectors_.set_connection_error_handler(
+          base::Bind(&Instance::OnConnectionLost, base::Unretained(this)));
+    }
+  }
+
   mojo::shell::Shell* const shell_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   const Identity identity_;
   const CapabilitySpec capability_spec_;
   const bool allow_any_application_;
   mojom::ShellClientPtr shell_client_;
   Binding<mojom::PIDReceiver> pid_receiver_binding_;
   BindingSet<mojom::Connector> connectors_;
   BindingSet<mojom::Shell> shell_bindings_;
   NativeRunner* runner_ = nullptr;
   base::ProcessId pid_ = base::kNullProcessId;
+  Instance* parent_ = nullptr;
+  std::set<Instance*> children_;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 Shell::TestAPI::TestAPI(Shell* shell) : shell_(shell) {}
 Shell::TestAPI::~TestAPI() {}
 
 bool Shell::TestAPI::HasRunningInstanceForName(const std::string& name) const {
   for (const auto& entry : shell_->identity_to_instance_) {
     if (entry.first.name() == name)
       return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(scoped_ptr<NativeRunnerFactory> native_runner_factory,
              mojom::ShellClientPtr catalog)
     : native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   mojom::ShellClientPtr client;
   mojom::ShellClientRequest request = GetProxy(&client);
-  Instance* instance = CreateInstance(CreateShellIdentity(),
+  Instance* instance = CreateInstance(Identity(), CreateShellIdentity(),
                                       GetPermissiveCapabilities());
   instance->StartWithClient(std::move(client));
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
@@ skipping 21 matching lines @@
 
   mojom::ShellClientPtr client;
   mojom::ShellClientRequest request = GetProxy(&client);
   Connect(std::move(params), std::move(client));
 
   return request;
 }
 
 void Shell::SetLoaderForName(scoped_ptr<Loader> loader,
                              const std::string& name) {
-  NameToLoaderMap::iterator it = name_to_loader_.find(name);
+  auto it = name_to_loader_.find(name);
   if (it != name_to_loader_.end())
     delete it->second;
   name_to_loader_[name] = loader.release();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, ShellClient implementation:
 
 bool Shell::AcceptConnection(Connection* connection) {
   // The only interface we expose is mojom::Shell, and access to this interface
   // is brokered by a policy specific to each caller, managed by the caller's
   // instance. Here we look to see who's calling, and forward to the caller's
   // instance to continue.
   Instance* instance = nullptr;
   for (const auto& entry : identity_to_instance_) {
     if (entry.second->id() == connection->GetRemoteInstanceID()) {
       instance = entry.second;
       break;
     }
   }
   DCHECK(instance);
   return instance->AcceptConnection(connection);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 void Shell::InitCatalog(mojom::ShellClientPtr catalog) {
-  Instance* instance =
-      CreateInstance(CreateCatalogIdentity(), CapabilitySpec());
+  Instance* instance = CreateInstance(CreateShellIdentity(),
+                                      CreateCatalogIdentity(),
+                                      CapabilitySpec());
   instance->StartWithClient(std::move(catalog));
 
   // TODO(beng): this doesn't work anymore.
   // Seed the catalog with manifest info for the shell & catalog.
   mojo::shell::mojom::ShellResolverPtr resolver;
   shell_connection_->connector()->ConnectToInterface(kCatalogName, &resolver);
   resolver->ResolveMojoName(kCatalogName, base::Bind(&EmptyResolverCallback));
   resolver->ResolveMojoName(kShellName, base::Bind(&EmptyResolverCallback));
 }
 
 void Shell::TerminateShellConnections() {
-  STLDeleteValues(&identity_to_instance_);
+  Instance* instance = GetExistingInstance(CreateShellIdentity());
+  DCHECK(instance);
+  OnInstanceError(instance);
 }
 
 void Shell::OnInstanceError(Instance* instance) {
   const Identity identity = instance->identity();
   // Remove the shell.
   auto it = identity_to_instance_.find(identity);
   DCHECK(it != identity_to_instance_.end());
   int id = instance->id();
   delete it->second;
   identity_to_instance_.erase(it);
@@ skipping 58 matching lines @@
                                  });
 }
 
 bool Shell::ConnectToExistingInstance(scoped_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingInstance((*params)->target());
   if (instance)
     instance->ConnectToClient(std::move(*params));
   return !!instance;
 }
 
-Shell::Instance* Shell::CreateInstance(const Identity& target,
+Shell::Instance* Shell::CreateInstance(const Identity& source,
+                                       const Identity& target,
                                        const CapabilitySpec& spec) {
   CHECK(target.user_id() != mojom::kInheritUserID);
   Instance* instance = new Instance(this, target, spec);
   DCHECK(identity_to_instance_.find(target) ==
          identity_to_instance_.end());
+  Instance* source_instance = GetExistingInstance(source);
+  if (source_instance)
+    source_instance->AddChild(instance);
   identity_to_instance_[target] = instance;
   mojom::InstanceInfoPtr info = instance->CreateInstanceInfo();
   instance_listeners_.ForAllPtrs(
       [this, &info](mojom::InstanceListener* listener) {
         listener->InstanceCreated(info.Clone());
       });
   return instance;
 }
 
 void Shell::AddInstanceListener(mojom::InstanceListenerPtr listener) {
@@ skipping 64 matching lines @@
     return;
 
   Identity source = params->source();
   // |capabilities_ptr| can be null when there is no manifest, e.g. for URL
   // types not resolvable by the resolver.
   CapabilitySpec capabilities = GetPermissiveCapabilities();
   if (!capabilities_ptr.is_null())
     capabilities = capabilities_ptr.To<CapabilitySpec>();
 
   // Clients that request "all_users" class from the shell are allowed to
-  // field connection requests from any user.
-  if (HasClass(capabilities, kCapabilityClass_AllUsers))
+  // field connection requests from any user. They also run with a synthetic
+  // user id generated here. The user id provided via Connect() is ignored.
+  if (HasClass(capabilities, kCapabilityClass_AllUsers)) {
     singletons_.insert(target.name());
+    target.set_user_id(base::GenerateGUID());
+  }
 
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
-  Instance* instance = CreateInstance(target, capabilities);
+  Instance* instance = CreateInstance(params->source(), target, capabilities);
 
   // Below are various paths through which a new Instance can be bound to a
   // ShellClient proxy.
   if (client.is_bound()) {
     // If a ShellClientPtr was provided, there's no more work to do: someone
     // is already holding a corresponding ShellClientRequest.
     instance->StartWithClient(std::move(client));
   } else if (!client_process_connection.is_null()) {
     // Likewise if a ClientProcessConnection was given via Connect(), it
     // provides the ShellClient proxy to use.
@@ skipping 42 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo