Make "all user" services work when packaged.

services/service_manager/service_manager.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 "services/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 21 matching lines @@
 namespace service_manager {
 
 namespace {
 
 const char kCatalogName[] = "service:catalog";
 const char kServiceManagerName[] = "service:service_manager";
 const char kCapability_UserID[] = "service_manager:user_id";
 const char kCapability_ClientProcess[] = "service_manager:client_process";
 const char kCapability_InstanceName[] = "service_manager:instance_name";
 const char kCapability_AllUsers[] = "service_manager:all_users";
+const char kCapability_InstancePerChild[] =
+    "service_manager:instance_per_child";
 const char kCapability_ServiceManager[] = "service_manager:service_manager";
 
 }  // namespace
 
 Identity CreateServiceManagerIdentity() {
   return Identity(kServiceManagerName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
   return Identity(kCatalogName, mojom::kRootUserID);
@@ skipping 26 matching lines @@
  public:
   Instance(service_manager::ServiceManager* service_manager,
            const Identity& identity,
            const InterfaceProviderSpecMap& interface_provider_specs)
       : service_manager_(service_manager),
         id_(GenerateUniqueID()),
         identity_(identity),
         interface_provider_specs_(interface_provider_specs),
         allow_any_application_(GetConnectionSpec().requires.count("*") == 1),
         pid_receiver_binding_(this),
+        state_(State::IDLE),
         weak_factory_(this) {
     if (identity_.name() == kServiceManagerName ||
         identity_.name() == kCatalogName) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {
     // Shutdown all bindings before we close the runner. This way the process
     // should see the pipes closed and exit, as well as waking up any potential
     // sync/WaitForIncomingResponse().
     service_.reset();
     if (pid_receiver_binding_.is_bound())
       pid_receiver_binding_.Close();
     connectors_.CloseAllBindings();
     service_manager_bindings_.CloseAllBindings();
 
-    // Notify the ServiceManager that this Instance is really going away.
-    service_manager_->OnInstanceStopped(identity_);
+    if (state_ == State::STARTING) {
+      service_manager_->NotifyServiceFailedToStart(identity_);
+    } else {
+      // Notify the ServiceManager that this Instance is really going away.
+      service_manager_->OnInstanceStopped(identity_);
+    }
 
     // Release |runner_| so that if we are called back to OnRunnerCompleted()
     // we know we're in the destructor.
     std::unique_ptr<NativeRunner> runner = std::move(runner_);
     runner.reset();
   }
 
-  Instance* parent() { return parent_; }
+  Instance* parent() const { return parent_; }
 
   void AddChild(std::unique_ptr<Instance> child) {
     child->parent_ = this;
     children_.insert(std::make_pair(child.get(), std::move(child)));
   }
 
   void RemoveChild(Instance* child) {
     auto it = children_.find(child);
     DCHECK(it != children_.end());
 
@@ skipping 15 matching lines @@
     Instance* source = service_manager_->GetExistingInstance(params->source());
     if (source)
       specs = source->interface_provider_specs_;
     service_->OnConnect(ServiceInfo(params->source(), specs),
                         params->TakeRemoteInterfaces());
     return true;
   }
 
   void StartWithService(mojom::ServicePtr service) {
     CHECK(!service_);
+    state_ = State::STARTING;
     service_ = std::move(service);
     service_.set_connection_error_handler(
         base::Bind(&Instance::OnServiceLost, base::Unretained(this),
                    service_manager_->GetWeakPtr()));
     service_->OnStart(ServiceInfo(identity_, interface_provider_specs_),
                       base::Bind(&Instance::OnInitializeResponse,
                                  base::Unretained(this)));
   }
 
   void StartWithClientProcessConnection(
@@ skipping 24 matching lines @@
     info->pid = pid_;
     return info;
   }
 
   const InterfaceProviderSpec& GetConnectionSpec() const {
     auto it = interface_provider_specs_.find(
         mojom::kServiceManager_ConnectorSpec);
     return it != interface_provider_specs_.end() ? it->second : empty_spec_;
   }
   const Identity& identity() const { return identity_; }
+  void set_identity(const Identity& identity) { identity_ = identity; }
   uint32_t id() const { return id_; }
 
   // Service:
   bool OnConnect(const ServiceInfo& remote_info,
                  InterfaceRegistry* registry) override {
     Instance* source =
         service_manager_->GetExistingInstance(remote_info.identity);
     DCHECK(source);
     if (HasCapability(source->GetConnectionSpec(),
                       kCapability_ServiceManager)) {
       registry->AddInterface<mojom::ServiceManager>(this);
       return true;
     }
     return false;
   }
 
  private:
+   enum class State {
+    // The service was not started yet.
+    IDLE,
+
+    // The service was started but the service manager hasn't received the
+    // initial response from it yet.
+    STARTING,
+
+    // The service was started successfully.
+    STARTED
+  };
+
   // mojom::Connector implementation:
   void Connect(const service_manager::Identity& in_target,
                mojom::InterfaceProviderRequest remote_interfaces,
                mojom::ClientProcessConnectionPtr client_process_connection,
                const ConnectCallback& callback) override {
     Identity target = in_target;
     if (target.user_id() == mojom::kInheritUserID)
       target.set_user_id(identity_.user_id());
 
     if (!ValidateIdentity(target, callback))
@@ skipping 138 matching lines @@
     CHECK_NE(mojom::kInvalidInstanceID, id);
     return id;
   }
 
   void PIDAvailable(base::ProcessId pid) {
     if (pid == base::kNullProcessId) {
       service_manager_->OnInstanceError(this);
       return;
     }
     pid_ = pid;
-    service_manager_->NotifyPIDAvailable(identity_, pid_);
   }
 
   void OnServiceLost(
       base::WeakPtr<service_manager::ServiceManager> service_manager) {
     service_.reset();
     OnConnectionLost(service_manager);
   }
 
   void OnConnectionLost(
       base::WeakPtr<service_manager::ServiceManager> service_manager) {
     // Any time a Connector is lost or we lose the Service connection, it
     // may have been the last pipe using this Instance. If so, clean up.
     if (service_manager && !service_) {
       if (connectors_.empty())
         service_manager->OnInstanceError(this);
       else
         service_manager->OnInstanceUnreachable(this);
     }
   }
 
   void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
+    state_ = State::STARTED;
     if (connector_request.is_pending()) {
       connectors_.AddBinding(this, std::move(connector_request));
       connectors_.set_connection_error_handler(
           base::Bind(&Instance::OnConnectionLost, base::Unretained(this),
                      service_manager_->GetWeakPtr()));
     }
+    service_manager_->NotifyServiceStarted(identity_, pid_);
   }
 
   // Callback when NativeRunner completes.
   void OnRunnerCompleted() {
     if (!runner_.get())
       return;  // We're in the destructor.
 
     service_manager_->OnInstanceError(this);
   }
 
   service_manager::ServiceManager* const service_manager_;
 
   // 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_;
+  Identity identity_;
   const InterfaceProviderSpecMap interface_provider_specs_;
   const InterfaceProviderSpec empty_spec_;
   const bool allow_any_application_;
   std::unique_ptr<NativeRunner> runner_;
   mojom::ServicePtr service_;
   mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
   mojo::BindingSet<mojom::Connector> connectors_;
   mojo::BindingSet<mojom::ServiceManager> service_manager_bindings_;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   InstanceMap children_;
+  State state_;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 ServiceManager::TestAPI::TestAPI(ServiceManager* service_manager)
     : service_manager_(service_manager) {}
 ServiceManager::TestAPI::~TestAPI() {}
 
@@ skipping 206 matching lines @@
     for (auto entry : identity_to_instance_) {
       if (entry.first.name() == identity.name() &&
           entry.first.instance() == identity.instance()) {
         return entry.second;
       }
     }
   }
   return nullptr;
 }
 
-void ServiceManager::NotifyPIDAvailable(const Identity& identity,
-                                        base::ProcessId pid) {
+void ServiceManager::NotifyServiceStarted(const Identity& identity,
+                                          base::ProcessId pid) {
   listeners_.ForAllPtrs(
       [identity, pid](mojom::ServiceManagerListener* listener) {
         listener->OnServiceStarted(identity, pid);
       });
 }
 
+void ServiceManager::NotifyServiceFailedToStart(const Identity& identity) {
+  listeners_.ForAllPtrs(
+      [identity](mojom::ServiceManagerListener* listener) {
+        listener->OnServiceFailedToStart(identity);
+      });
+}
+
 bool ServiceManager::ConnectToExistingInstance(
     std::unique_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingInstance((*params)->target());
   return instance && instance->ConnectToService(params);
 }
 
 ServiceManager::Instance* ServiceManager::CreateInstance(
     const Identity& source,
     const Identity& target,
     const InterfaceProviderSpecMap& specs) {
@@ skipping 82 matching lines @@
     instance_name = result->qualifier;
   }
   // |result->interface_provider_specs| can be empty when there is no manifest,
   // e.g. for URL types not resolvable by the resolver.
   InterfaceProviderSpec connection_spec = GetPermissiveInterfaceProviderSpec();
   auto it = result->interface_provider_specs.find(
       mojom::kServiceManager_ConnectorSpec);
   if (it != result->interface_provider_specs.end())
     connection_spec = it->second;
 
+  const Identity original_target(params->target());
   const std::string user_id =
       HasCapability(connection_spec, kCapability_AllUsers)
           ? base::GenerateGUID() : params->target().user_id();
   const Identity target(params->target().name(), user_id, instance_name);
   params->set_target(target);
 
   // It's possible that when this manifest request was issued, another one was
   // already in-progress and completed by the time this one did, and so the
   // requested application may already be running.
   if (ConnectToExistingInstance(&params))
@@ skipping 40 matching lines @@
     // anything more.
     // TODO(beng): There may be some cases where it's valid to have an empty
     // spec, so we should probably include a return value in |result|.
     if (result->interface_provider_specs.empty()) {
       if (!params->connect_callback().is_null())
         params->connect_callback().Run(mojom::ConnectResult::ACCESS_DENIED, "");
       return;
     }
 
     if (target.name() != result->resolved_name) {
+      // This service is part of a package.
+      std::string target_user_id = target.user_id();
+      std::string factory_instance_name = instance_name;
+      bool instance_per_child = result->package_spec.has_value() &&
+          HasCapability(result->package_spec.value(),
+                        kCapability_InstancePerChild);
+      if (instance_per_child) {
+        // If configured to start a new instance, create a random instance name
+        // for the factory so that we don't reuse an existing process.
+        factory_instance_name = base::GenerateGUID();
+      } else {
+        // Use the original user ID so the existing embedder factory can
+        // be found and used to create the new service.
+        target_user_id = original_target.user_id();
+        Identity packaged_service_target(target);
+        packaged_service_target.set_user_id(original_target.user_id());
+        instance->set_identity(packaged_service_target);
+      }
       instance->StartWithService(std::move(service));
-      Identity factory(result->resolved_name, target.user_id(),
-                       instance_name);
+
+      Identity factory(result->resolved_name, target_user_id,
+                       factory_instance_name);
       CreateServiceWithFactory(factory, target.name(), std::move(request));
     } else {
       base::FilePath package_path;
       if (!service_overrides_ || !service_overrides_->GetExecutablePathOverride(
             target.name(), &package_path)) {
         package_path = result->package_path;
       }
 
       Identity source_instance_identity;
       base::debug::Alias(&has_source_instance);
@@ skipping 15 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager