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 107 matching lines @@
  public:
   Instance(service_manager::ServiceManager* service_manager,
            const Identity& identity,
            const InterfaceProviderSpec& connection_spec)
       : service_manager_(service_manager),
         id_(GenerateUniqueID()),
         identity_(identity),
         connection_spec_(connection_spec),
         allow_any_application_(connection_spec.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 29 matching lines @@
       interfaces.erase("*");
     }
 
     service_->OnConnect(params->source(), params->TakeRemoteInterfaces(),
                         interfaces, capabilities);
     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(identity_,
                       base::Bind(&Instance::OnInitializeResponse,
                                  base::Unretained(this)));
   }
 
   void StartWithClientProcessConnection(
@@ skipping 22 matching lines @@
     info->id = id_;
     info->identity = identity_;
     info->pid = pid_;
     return info;
   }
 
   const InterfaceProviderSpec& connection_spec() const {
     return connection_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 Identity& remote_identity,
                  InterfaceRegistry* registry) override {
     Instance* source = service_manager_->GetExistingInstance(remote_identity);
     DCHECK(source);
     if (HasCapability(source->connection_spec_, kCapability_ServiceManager)) {
       registry->AddInterface<mojom::ServiceManager>(this);
       return true;
     }
     return false;
   }
 
  private:
+   enum class State {
+    // This connection was not started yet.

[Ken Rockot(use gerrit already), 2016/10/21 19:52:33]

nit: in these comments I think s/connection/instance/ is more accurate

[Jay Civelli, 2016/10/21 20:48:33]

Done.

+    IDLE,
+
+    // The connection was started but no success was reported.
+    STARTING,
+
+    // The connection 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 137 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 InterfaceProviderSpec connection_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 201 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 InterfaceProviderSpec& connection_spec) {
@@ skipping 81 matching lines @@
   if (instance_name == GetNamePath(params->target().name()) &&
       result->qualifier != GetNamePath(result->resolved_name)) {
     instance_name = result->qualifier;
   }
   // |result->connection_spec| can be null when there is no manifest, e.g. for
   // URL types not resolvable by the resolver.
   InterfaceProviderSpec connection_spec = GetPermissiveInterfaceProviderSpec();
   if (result->connection_spec.has_value())
     connection_spec = result->connection_spec.value();
 
+  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 30 matching lines @@
     // Likewise if a ClientProcessConnection was given via Connect(), it
     // provides the Service proxy to use.
     instance->StartWithClientProcessConnection(
         std::move(client_process_connection));
   } else {
     // Otherwise we create a new Service pipe.
     mojom::ServiceRequest request = GetProxy(&service);
     CHECK(!result->package_path.empty() && result->connection_spec.has_value());
 
     if (target.name() != result->resolved_name) {
+      // When part of a packaged app, use the original user ID.

[Ken Rockot(use gerrit already), 2016/10/21 19:52:33]

nit: s/app/service/

[Jay Civelli, 2016/10/21 20:48:33]

Done.

+      Identity packaged_app_target(target);
+      packaged_app_target.set_user_id(original_target.user_id());
+      instance->set_identity(packaged_app_target);
       instance->StartWithService(std::move(service));
-      Identity factory(result->resolved_name, target.user_id(),
+      Identity factory(result->resolved_name, original_target.user_id(),
                        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;
@@ skipping 16 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