Replace ServiceInfo with BindSourceInfo.

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 200 matching lines @@
     if (!AllowsInterface(params->source(), source_connection_spec, identity_,
                          GetConnectionSpec(), params->interface_name())) {
       params->set_response_data(mojom::ConnectResult::ACCESS_DENIED, identity_);
       return false;
     }
 
     params->set_response_data(mojom::ConnectResult::SUCCEEDED, identity_);
 
     pending_service_connections_++;
     service_->OnBindInterface(
-        ServiceInfo(params->source(), source_specs),
-        params->interface_name(),
-        params->TakeInterfaceRequestPipe(),
+        BindSourceInfo(
+            params->source(),
+            GetRequestedCapabilities(source_connection_spec, identity_)),
+        params->interface_name(), params->TakeInterfaceRequestPipe(),
         base::Bind(&Instance::OnConnectComplete, base::Unretained(this)));
     return true;
   }
 
   void OnConnectComplete() {
     DCHECK_GT(pending_service_connections_, 0);
     pending_service_connections_--;
   }
 
   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::OnStartComplete,
-                                 base::Unretained(this)));
+    service_->OnStart(identity_, base::Bind(&Instance::OnStartComplete,
+                                            base::Unretained(this)));
   }
 
   bool StartWithFilePath(const base::FilePath& path) {
     DCHECK(!service_);
     DCHECK(!path.empty());
     runner_ = service_manager_->service_process_launcher_factory_->Create(path);
     if (!runner_)
       return false;
     bool start_sandboxed = false;
     mojom::ServicePtr service = runner_->Start(
@@ skipping 25 matching lines @@
   const InterfaceProviderSpec& GetSpec(const std::string& spec) const {
     auto it = interface_provider_specs_.find(spec);
     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:
-  void OnBindInterface(const ServiceInfo& source_info,
+  void OnBindInterface(const BindSourceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle interface_pipe) override {
     Instance* source =
         service_manager_->GetExistingInstance(source_info.identity);
     DCHECK(source);
     if (interface_name == mojom::ServiceManager::Name_ &&
         HasCapability(source->GetConnectionSpec(),
                       kCapability_ServiceManager)) {
       mojom::ServiceManagerRequest request =
           mojo::MakeRequest<mojom::ServiceManager>(std::move(interface_pipe));
@@ skipping 337 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 class ServiceManager::ServiceImpl : public Service {
  public:
   explicit ServiceImpl(ServiceManager* service_manager)
       : service_manager_(service_manager) {}
   ~ServiceImpl() override {}
 
   // Service:
-  void OnBindInterface(const ServiceInfo& source_info,
+  void OnBindInterface(const BindSourceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle interface_pipe) override {
     // The only interface ServiceManager exposes is mojom::ServiceManager, and
     // access to this interface is brokered by a policy specific to each caller,
     // managed by the caller's instance. Here we look to see who's calling,
     // and forward to the caller's instance to continue.
     Instance* instance = nullptr;
     for (const auto& entry : service_manager_->identity_to_instance_) {
       if (entry.first == source_info.identity) {
         instance = entry.second;
@@ skipping 483 matching lines @@
                             instance->identity());
   if (params->HasInterfaceRequestInfo())
     instance->CallOnBindInterface(&params);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager