Perform InterfaceProviderSpec intersection in the ServiceManager

services/service_manager/public/cpp/lib/interface_registry.cc

 // Copyright 2016 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/public/cpp/interface_registry.h"
 
 #include <sstream>
 
 #include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "services/service_manager/public/cpp/connection.h"
 
 namespace service_manager {
 namespace {
 
-// Returns the set of capabilities required from the target.
+void SerializeIdentity(const Identity& identity, std::stringstream* stream) {
+  *stream << identity.name() << "@" << identity.instance() << " run as: "
+          << identity.user_id();
+}
+
+void SerializeSpec(const InterfaceProviderSpec& spec,
+                   std::stringstream* stream) {
+  *stream << "  Providing:\n";
+  for (const auto& entry : spec.provides) {
+    *stream << "    capability: " << entry.first << " containing interfaces:\n";
+    for (const auto& interface_name : entry.second)
+      *stream << "      " << interface_name << "\n";
+  }
+  *stream << "\n  Requiring:\n";
+  for (const auto& entry : spec.requires) {
+    *stream << "    From: " << entry.first << ":\n";
+    for (const auto& capability_name : entry.second)
+      *stream << "      " << capability_name << "\n";
+  }
+}
+
+}  // namespace
+
 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;
 }
 
-// Generates a single set of interfaces that is the union of all interfaces
-// exposed by the target for the capabilities requested by the source.
 InterfaceSet GetInterfacesToExpose(
     const InterfaceProviderSpec& source_spec,
     const Identity& target,
     const InterfaceProviderSpec& target_spec) {
   InterfaceSet exposed_interfaces;
   // TODO(beng): remove this once we can assert that an InterfaceRegistry must
   //             always be constructed with a valid identity.
   if (!target.IsValid()) {
     exposed_interfaces.insert("*");
     return exposed_interfaces;
   }
   CapabilitySet capabilities = GetRequestedCapabilities(source_spec, target);
   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)
         exposed_interfaces.insert(interface_name);
     }
   }
   return exposed_interfaces;
 }
 
-void SerializeIdentity(const Identity& identity, std::stringstream* stream) {
-  *stream << identity.name() << "@" << identity.instance() << " run as: "
-          << identity.user_id();
-}
-
-void SerializeSpec(const InterfaceProviderSpec& spec,
-                   std::stringstream* stream) {
-  *stream << "  Providing:\n";
-  for (const auto& entry : spec.provides) {
-    *stream << "    capability: " << entry.first << " containing interfaces:\n";
-    for (const auto& interface_name : entry.second)
-      *stream << "      " << interface_name << "\n";
-  }
-  *stream << "\n  Requiring:\n";
-  for (const auto& entry : spec.requires) {
-    *stream << "    From: " << entry.first << ":\n";
-    for (const auto& capability_name : entry.second)
-      *stream << "      " << capability_name << "\n";
-  }
-}
-
-}  // namespace
-
 InterfaceRegistry::InterfaceRegistry(const std::string& name)
     : binding_(this),
       name_(name),
       weak_factory_(this) {}
 InterfaceRegistry::~InterfaceRegistry() {}
 
 void InterfaceRegistry::Bind(
     mojom::InterfaceProviderRequest local_interfaces_request,
     const Identity& local_identity,
     const InterfaceProviderSpec& local_interface_provider_spec,
@@ skipping 156 matching lines @@
       exposed_interfaces_.size() == 1 && exposed_interfaces_.count("*") == 1;
 }
 
 void InterfaceRegistry::OnConnectionError() {
   std::list<base::Closure> closures = connection_lost_closures_;
   for (const auto& closure : closures)
     closure.Run();
 }
 
 }  // namespace service_manager