Support reading multiple InterfaceProviderSpecs from manifests

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 100 matching lines @@
 // Service Manager.
 class ServiceManager::Instance
     : public mojom::Connector,
       public mojom::PIDReceiver,
       public Service,
       public InterfaceFactory<mojom::ServiceManager>,
       public mojom::ServiceManager {
  public:
   Instance(service_manager::ServiceManager* service_manager,
            const Identity& identity,
-           const InterfaceProviderSpec& connection_spec)
+           const InterfaceProviderSpecMap& interface_provider_specs)
       : service_manager_(service_manager),
         id_(GenerateUniqueID()),
         identity_(identity),
-        connection_spec_(connection_spec),
-        allow_any_application_(connection_spec.requires.count("*") == 1),
+        interface_provider_specs_(interface_provider_specs),
+        allow_any_application_(GetConnectionSpec().requires.count("*") == 1),
         pid_receiver_binding_(this),
         weak_factory_(this) {
     if (identity_.name() == kServiceManagerName ||
         identity_.name() == kCatalogName) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {
@@ skipping 33 matching lines @@
   bool ConnectToService(std::unique_ptr<ConnectParams>* connect_params) {
     if (!service_.is_bound())
       return false;
 
     std::unique_ptr<ConnectParams> params(std::move(*connect_params));
     if (!params->connect_callback().is_null()) {
         params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                        identity_.user_id());
     }
 
+    InterfaceProviderSpec connection_spec = GetConnectionSpec();
     CapabilitySet capabilities;
     InterfaceSet interfaces;
     Instance* source = service_manager_->GetExistingInstance(params->source());
     if (source) {
-      GetCapabilitiesAndInterfacesForConnection(source->connection_spec_,
-                                                identity_, connection_spec_,
+      GetCapabilitiesAndInterfacesForConnection(source->GetConnectionSpec(),
+                                                identity_, connection_spec,
                                                 &capabilities, &interfaces);
     } else {
       interfaces.insert("*");
     }
 
     // The target has specified that sources must request one of its provided
     // classes instead of specifying a wild-card for interfaces.
-    if (HasCapability(connection_spec_, kCapability_ExplicitClass) &&
+    if (HasCapability(connection_spec, kCapability_ExplicitClass) &&
         (interfaces.count("*") != 0)) {
       interfaces.erase("*");
     }
 
-    service_->OnConnect(params->source(), params->TakeRemoteInterfaces(),
-                        interfaces, capabilities);
+    InterfaceProviderSpecMap specs;
+    if (source)
+      specs = source->interface_provider_specs_;
+    service_->OnConnect(ServiceInfo(params->source(), specs),
+                        params->TakeRemoteInterfaces(), interfaces,
+                        capabilities);
     return true;
   }
 
   void StartWithService(mojom::ServicePtr service) {
     CHECK(!service_);
     service_ = std::move(service);
     service_.set_connection_error_handler(
         base::Bind(&Instance::OnServiceLost, base::Unretained(this),
                    service_manager_->GetWeakPtr()));
-    service_->OnStart(identity_,
+    service_->OnStart(ServiceInfo(identity_, interface_provider_specs_),
                       base::Bind(&Instance::OnInitializeResponse,
                                  base::Unretained(this)));
   }
 
   void StartWithClientProcessConnection(
       mojom::ClientProcessConnectionPtr client_process_connection) {
     mojom::ServicePtr service;
     service.Bind(mojom::ServicePtrInfo(
         std::move(client_process_connection->service), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
     StartWithService(std::move(service));
   }
 
   void StartWithFilePath(const base::FilePath& path) {
     CHECK(!service_);
     runner_ = service_manager_->native_runner_factory_->Create(path);
     bool start_sandboxed = false;
     mojom::ServicePtr service = runner_->Start(
         path, identity_, start_sandboxed,
         base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
         base::Bind(&Instance::OnRunnerCompleted, weak_factory_.GetWeakPtr()));
     StartWithService(std::move(service));
   }
 
-  mojom::ServiceInfoPtr CreateServiceInfo() const {
-    mojom::ServiceInfoPtr info(mojom::ServiceInfo::New());
+  mojom::RunningServiceInfoPtr CreateRunningServiceInfo() const {
+    mojom::RunningServiceInfoPtr info(mojom::RunningServiceInfo::New());
     info->id = id_;
     info->identity = identity_;
     info->pid = pid_;
     return info;
   }
 
-  const InterfaceProviderSpec& connection_spec() const {
-    return connection_spec_;
+  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_; }
   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)) {
+    if (HasCapability(source->GetConnectionSpec(),
+                      kCapability_ServiceManager)) {
       registry->AddInterface<mojom::ServiceManager>(this);
       return true;
     }
     return false;
   }
 
  private:
   // mojom::Connector implementation:
   void Connect(const service_manager::Identity& in_target,
                mojom::InterfaceProviderRequest remote_interfaces,
@@ skipping 59 matching lines @@
       return false;
     }
     return true;
   }
 
   bool ValidateClientProcessConnection(
       mojom::ClientProcessConnectionPtr* client_process_connection,
       const Identity& target,
       const ConnectCallback& callback) {
     if (!client_process_connection->is_null()) {
-      if (!HasCapability(connection_spec_, kCapability_ClientProcess)) {
+      if (!HasCapability(GetConnectionSpec(), kCapability_ClientProcess)) {
         LOG(ERROR) << "Instance: " << identity_.name() << " attempting "
                    << "to register an instance for a process it created for "
                    << "target: " << target.name() << " without the "
                    << "service:service_manager{client_process} capability "
                    << "class.";
         callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                      mojom::kInheritUserID);
         return false;
       }
 
@@ skipping 13 matching lines @@
         callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                      mojom::kInheritUserID);
         return false;
       }
     }
     return true;
   }
 
   bool ValidateConnectionSpec(const Identity& target,
                               const ConnectCallback& callback) {
+    InterfaceProviderSpec connection_spec = GetConnectionSpec();
     // TODO(beng): Need to do the following additional policy validation of
     // whether this instance is allowed to connect using:
     // - a non-null client_process_connection.
     if (target.user_id() != identity_.user_id() &&
         target.user_id() != mojom::kRootUserID &&
-        !HasCapability(connection_spec_, kCapability_UserID)) {
+        !HasCapability(connection_spec, kCapability_UserID)) {
       LOG(ERROR) << "Instance: " << identity_.name()
                  << " running as: " << identity_.user_id()
                  << " attempting to connect to: " << target.name()
                  << " as: " << target.user_id() << " without "
                  << " the service:service_manager{user_id} capability.";
       callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                    mojom::kInheritUserID);
       return false;
     }
     if (!target.instance().empty() &&
         target.instance() != GetNamePath(target.name()) &&
-        !HasCapability(connection_spec_, kCapability_InstanceName)) {
+        !HasCapability(connection_spec, kCapability_InstanceName)) {
       LOG(ERROR) << "Instance: " << identity_.name() << " attempting to "
                  << "connect to " << target.name()
                  << " using Instance name: " << target.instance()
                  << " without the "
                  << "service:service_manager{instance_name} capability.";
       callback.Run(mojom::ConnectResult::ACCESS_DENIED, mojom::kInheritUserID);
       return false;
     }
 
     if (allow_any_application_ ||
-        connection_spec_.requires.find(target.name()) !=
-            connection_spec_.requires.end()) {
+        connection_spec.requires.find(target.name()) !=
+            connection_spec.requires.end()) {
       return true;
     }
     LOG(ERROR) << "InterfaceProviderSpec prevented connection from: "
                << identity_.name() << " to: " << target.name();
     callback.Run(mojom::ConnectResult::ACCESS_DENIED, mojom::kInheritUserID);
     return false;
   }
 
   uint32_t GenerateUniqueID() const {
     static uint32_t id = mojom::kInvalidInstanceID;
@@ skipping 46 matching lines @@
     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_;
-  const InterfaceProviderSpec connection_spec_;
+  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_;
   base::WeakPtrFactory<Instance> weak_factory_;
@@ skipping 25 matching lines @@
       weak_ptr_factory_(this) {
   mojom::ServicePtr service;
   mojom::ServiceRequest request = mojo::GetProxy(&service);
 
   InterfaceProviderSpec spec;
   spec.provides[kCapability_ServiceManager].insert(
       "service_manager::mojom::ServiceManager");
   spec.requires["*"].insert("service_manager:service_factory");
   spec.requires["service:catalog"].insert("service_manager:resolver");
   spec.requires["service:tracing"].insert("app");
+  InterfaceProviderSpecMap specs;
+  specs[mojom::kServiceManager_ConnectorSpec] = spec;
 
   service_manager_instance_ =
-      CreateInstance(Identity(), CreateServiceManagerIdentity(), spec);
+      CreateInstance(Identity(), CreateServiceManagerIdentity(), specs);
   service_manager_instance_->StartWithService(std::move(service));
   singletons_.insert(kServiceManagerName);
   service_context_.reset(new ServiceContext(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 ServiceManager::~ServiceManager() {
   // Ensure we tear down the ServiceManager instance last. This is to avoid
@@ skipping 61 matching lines @@
 
 void ServiceManager::InitCatalog(mojom::ServicePtr catalog) {
   // TODO(beng): It'd be great to build this from the manifest, however there's
   //             a bit of a chicken-and-egg problem.
   InterfaceProviderSpec spec;
   spec.provides["app"].insert("filesystem::mojom::Directory");
   spec.provides["catalog:catalog"].insert("catalog::mojom::Catalog");
   spec.provides["service_manager:resolver"].insert(
       "service_manager::mojom::Resolver");
   spec.provides["control"].insert("catalog::mojom::CatalogControl");
+  InterfaceProviderSpecMap specs;
+  specs[mojom::kServiceManager_ConnectorSpec] = spec;
+
   Instance* instance = CreateInstance(
-      CreateServiceManagerIdentity(), CreateCatalogIdentity(), spec);
+      CreateServiceManagerIdentity(), CreateCatalogIdentity(), specs);
   singletons_.insert(kCatalogName);
   instance->StartWithService(std::move(catalog));
 }
 
 mojom::Resolver* ServiceManager::GetResolver(const Identity& identity) {
   auto iter = identity_to_resolver_.find(identity);
   if (iter != identity_to_resolver_.end())
     return iter->second.get();
 
   mojom::ResolverPtr resolver_ptr;
@@ skipping 96 matching lines @@
 
 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) {
+    const InterfaceProviderSpecMap& specs) {
   CHECK(target.user_id() != mojom::kInheritUserID);
 
-  std::unique_ptr<Instance> instance(
-      new Instance(this, target, connection_spec));
+  auto instance = base::MakeUnique<Instance>(this, target, specs);
   Instance* raw_instance = instance.get();
 
   Instance* source_instance = GetExistingInstance(source);
   if (source_instance)
     source_instance->AddChild(std::move(instance));
   else
     root_instances_.insert(std::make_pair(raw_instance, std::move(instance)));
 
   // NOTE: |instance| has been passed elsewhere. Use |raw_instance| from this
   // point forward. It's safe for the extent of this method.
 
   auto result =
       identity_to_instance_.insert(std::make_pair(target, raw_instance));
   DCHECK(result.second);
 
-  mojom::ServiceInfoPtr info = raw_instance->CreateServiceInfo();
+  mojom::RunningServiceInfoPtr info = raw_instance->CreateRunningServiceInfo();
   listeners_.ForAllPtrs([&info](mojom::ServiceManagerListener* listener) {
     listener->OnServiceCreated(info.Clone());
   });
 
   return raw_instance;
 }
 
 void ServiceManager::AddListener(mojom::ServiceManagerListenerPtr listener) {
   // TODO(beng): filter instances provided by those visible to this service.
-  std::vector<mojom::ServiceInfoPtr> instances;
+  std::vector<mojom::RunningServiceInfoPtr> instances;
   instances.reserve(identity_to_instance_.size());
   for (auto& instance : identity_to_instance_)
-    instances.push_back(instance.second->CreateServiceInfo());
+    instances.push_back(instance.second->CreateRunningServiceInfo());
   listener->OnInit(std::move(instances));
 
   listeners_.AddPtr(std::move(listener));
 }
 
 void ServiceManager::CreateServiceWithFactory(const Identity& service_factory,
                                               const std::string& name,
                                               mojom::ServiceRequest request) {
   mojom::ServiceFactory* factory = GetServiceFactory(service_factory);
   factory->CreateService(std::move(request), name);
@@ skipping 32 matching lines @@
   // If this request was originated by a specific Instance and that Instance is
   // no longer around, we ignore this response.
   if (has_source_instance && !source_instance)
     return;
 
   std::string instance_name = params->target().instance();
   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.
+  // |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();
-  if (result->connection_spec.has_value())
-    connection_spec = result->connection_spec.value();
+  auto it = result->interface_provider_specs.find(
+      mojom::kServiceManager_ConnectorSpec);
+  if (it != result->interface_provider_specs.end())
+    connection_spec = it->second;
 
   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.
@@ skipping 12 matching lines @@
   if (HasCapability(connection_spec, kCapability_AllUsers)) {
     singletons_.insert(target.name());
     source_identity_for_creation = CreateServiceManagerIdentity();
   } else {
     source_identity_for_creation = params->source();
   }
 
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
   Instance* instance = CreateInstance(source_identity_for_creation,
-                                      target, connection_spec);
+                                      target, result->interface_provider_specs);
 
   // Below are various paths through which a new Instance can be bound to a
   // Service proxy.
   if (service.is_bound()) {
     // If a ServicePtr was provided, there's no more work to do: someone
     // is already holding a corresponding ServiceRequest.
     instance->StartWithService(std::move(service));
   } else if (!client_process_connection.is_null()) {
     // 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());
+    CHECK(!result->package_path.empty());
+
+    // The catalog was unable to read a manifest for this service. We can't do
+    // 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) {
       instance->StartWithService(std::move(service));
       Identity factory(result->resolved_name, 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)) {
@@ skipping 20 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