Revise InterfaceRegistry API to support filtering interfaces @ Bind() time.

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_ExplicitClass[] = "service_manager:explicit_class";
 const char kCapability_ServiceManager[] = "service_manager:service_manager";
 
 }  // namespace
 
 Identity CreateServiceManagerIdentity() {
   return Identity(kServiceManagerName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
   return Identity(kCatalogName, mojom::kRootUserID);
 }
 
 InterfaceProviderSpec GetPermissiveInterfaceProviderSpec() {
   InterfaceProviderSpec spec;
   InterfaceSet interfaces;
   interfaces.insert("*");
   spec.requires["*"] = interfaces;
   return spec;
 }
 
-CapabilitySet GetRequestedCapabilities(const InterfaceProviderSpec& source_spec,
-                                       const Identity& target) {
-  CapabilitySet capabilities;
-
-  // Start by looking for specs specific to the supplied identity.
-  auto it = source_spec.requires.find(target.name());
-  if (it != source_spec.requires.end()) {
-    std::copy(it->second.begin(), it->second.end(),
-              std::inserter(capabilities, capabilities.begin()));
-  }
-
-  // Apply wild card rules too.
-  it = source_spec.requires.find("*");
-  if (it != source_spec.requires.end()) {
-    std::copy(it->second.begin(), it->second.end(),
-              std::inserter(capabilities, capabilities.begin()));
-  }
-  return capabilities;
-}
-
-void GetCapabilitiesAndInterfacesForConnection(
-    const InterfaceProviderSpec& source_spec,
-    const Identity& target,
-    const InterfaceProviderSpec& target_spec,
-    CapabilitySet* capabilities,
-    InterfaceSet* interfaces) {
-  DCHECK(capabilities && interfaces);
-  *capabilities = GetRequestedCapabilities(source_spec, target);
-  // Flatten all interfaces from capabilities requested by the source into the
-  // allowed interface set in the request.
-  for (const auto& capability : *capabilities) {
-    auto it = target_spec.provides.find(capability);
-    if (it != target_spec.provides.end()) {
-      for (const auto& interface_name : it->second)
-        interfaces->insert(interface_name);
-    }
-  }
-}
-
 bool HasCapability(const InterfaceProviderSpec& spec,
                    const std::string& capability) {
   auto it = spec.requires.find(kServiceManagerName);
   if (it == spec.requires.end())
     return false;
   return it->second.find(capability) != it->second.end();
 }
 
 // Encapsulates a connection to an instance of a service, tracked by the
 // Service Manager.
@@ skipping 58 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;
+    InterfaceProviderSpecMap specs;
     Instance* source = service_manager_->GetExistingInstance(params->source());
-    if (source) {
-      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) &&
-        (interfaces.count("*") != 0)) {
-      interfaces.erase("*");
-    }
-
-    InterfaceProviderSpecMap specs;
     if (source)
       specs = source->interface_provider_specs_;
     service_->OnConnect(ServiceInfo(params->source(), specs),
-                        params->TakeRemoteInterfaces(), interfaces,
-                        capabilities);
+                        params->TakeRemoteInterfaces());
     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(ServiceInfo(identity_, interface_provider_specs_),
@@ skipping 694 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