Eliminate InterfaceRegistry

services/service_manager/public/cpp/interface_registry.h

Index: services/service_manager/public/cpp/interface_registry.h
diff --git a/services/service_manager/public/cpp/interface_registry.h b/services/service_manager/public/cpp/interface_registry.h
deleted file mode 100644
index 96e23a764435ec4af7a4b0b0da3534dedfaba639..0000000000000000000000000000000000000000
--- a/services/service_manager/public/cpp/interface_registry.h
+++ /dev/null
@@ -1,240 +0,0 @@
-// 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.
-
-#ifndef SERVICES_SERVICE_MANAGER_PUBLIC_CPP_INTERFACE_REGISTRY_H_
-#define SERVICES_SERVICE_MANAGER_PUBLIC_CPP_INTERFACE_REGISTRY_H_
-
-#include <list>
-#include <memory>
-#include <queue>
-#include <set>
-#include <utility>
-
-#include "base/callback.h"
-#include "base/memory/ptr_util.h"
-#include "mojo/public/cpp/bindings/binding.h"
-#include "services/service_manager/public/cpp/identity.h"
-#include "services/service_manager/public/cpp/interface_provider_spec.h"
-#include "services/service_manager/public/cpp/lib/callback_binder.h"
-#include "services/service_manager/public/cpp/lib/interface_factory_binder.h"
-#include "services/service_manager/public/interfaces/interface_provider.mojom.h"
-
-namespace service_manager {
-class Connection;
-class InterfaceBinder;
-
-// Returns the set of capabilities required from the target.
-CapabilitySet GetRequestedCapabilities(const InterfaceProviderSpec& source_spec,
-                                       const Identity& target);
-
-// 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);
-
-// An implementation of mojom::InterfaceProvider that allows the user to
-// register services to be exposed to another application.
-//
-// To use, define a class that implements your specific interface. Then
-// implement an InterfaceFactory<Foo> that binds instances of FooImpl to
-// InterfaceRequest<Foo>s and register that on the registry like this:
-//
-//   registry.AddInterface(&factory);
-//
-// Or, if you have multiple factories implemented by the same type, explicitly
-// specify the interface to register the factory for:
-//
-//   registry.AddInterface<Foo>(&my_foo_and_bar_factory_);
-//   registry.AddInterface<Bar>(&my_foo_and_bar_factory_);
-//
-// The InterfaceFactory must outlive the InterfaceRegistry.
-//
-// Additionally you may specify a default InterfaceBinder to handle requests for
-// interfaces unhandled by any registered InterfaceFactory. Just as with
-// InterfaceFactory, the default InterfaceBinder supplied must outlive
-// InterfaceRegistry.
-//
-class InterfaceRegistry : public mojom::InterfaceProvider {
- public:
-  using Binder = base::Callback<void(const std::string&,
-                                     mojo::ScopedMessagePipeHandle)>;
-
-  class TestApi {
-   public:
-    explicit TestApi(InterfaceRegistry* registry) : registry_(registry) {}
-    ~TestApi() {}
-
-    void SetInterfaceBinderForName(InterfaceBinder* binder,
-                                   const std::string& interface_name) {
-      registry_->SetInterfaceBinderForName(
-          base::WrapUnique(binder), interface_name);
-    }
-
-    template <typename Interface>
-    void GetLocalInterface(mojo::InterfaceRequest<Interface> request) {
-      GetLocalInterface(Interface::Name_, request.PassMessagePipe());
-    }
-
-    void GetLocalInterface(const std::string& name,
-                           mojo::ScopedMessagePipeHandle handle) {
-      registry_->GetInterface(name, std::move(handle));
-    }
-
-   private:
-    InterfaceRegistry* registry_;
-    DISALLOW_COPY_AND_ASSIGN(TestApi);
-  };
-
-  // Construct an unbound InterfaceRegistry. This object will not bind requests
-  // for interfaces until Bind() is called. |name| is used for error reporting
-  // and should reflect the name of the InterfaceProviderSpec pair that controls
-  // which interfaces can be bound via this InterfaceRegistry.
-  explicit InterfaceRegistry(const std::string& name);
-  ~InterfaceRegistry() override;
-
-  // Sets a default handler for incoming interface requests which are allowed by
-  // capability filters but have no registered handler in this registry.
-  void set_default_binder(const Binder& binder) { default_binder_ = binder; }
-
-  // Binds a request for an InterfaceProvider from a remote source.
-  // |remote_info| contains the the identity of the remote, and the remote's
-  // InterfaceProviderSpec, which will be intersected with the local's exports
-  // to determine what interfaces may be bound.
-  void Bind(mojom::InterfaceProviderRequest request,
-            const Identity& local_identity,
-            const InterfaceProviderSpec& local_interface_provider_spec,
-            const Identity& remote_identity,
-            const InterfaceProviderSpec& remote_interface_provider_spec);
-
-  // Serializes the contents of the registry (including the local and remote
-  // specs) to a stringstream.
-  void Serialize(std::stringstream* stream);
-
-  base::WeakPtr<InterfaceRegistry> GetWeakPtr();
-
-  // Allows |Interface| to be exposed via this registry. Requests to bind will
-  // be handled by |factory|. Returns true if the interface was exposed, false
-  // if Connection policy prevented exposure.
-  template <typename Interface>
-  bool AddInterface(InterfaceFactory<Interface>* factory) {
-    return SetInterfaceBinderForName(
-        base::MakeUnique<internal::InterfaceFactoryBinder<Interface>>(factory),
-        Interface::Name_);
-  }
-
-  // Like AddInterface above, except supplies a callback to bind the MP instead
-  // of an InterfaceFactory, and optionally provides a task runner where the
-  // callback will be run.
-  template <typename Interface>
-  bool AddInterface(
-      const base::Callback<void(mojo::InterfaceRequest<Interface>)>& callback,
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner =
-          nullptr) {
-    return SetInterfaceBinderForName(
-        base::MakeUnique<internal::CallbackBinder<Interface>>(callback,
-                                                              task_runner),
-        Interface::Name_);
-  }
-  bool AddInterface(
-      const std::string& name,
-      const base::Callback<void(mojo::ScopedMessagePipeHandle)>& callback,
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner =
-          nullptr);
-
-  template <typename Interface>
-  void RemoveInterface() {
-    RemoveInterface(Interface::Name_);
-  }
-  void RemoveInterface(const std::string& name);
-
-  // Temporarily prevent incoming interface requests from being bound. Incoming
-  // requests will be queued internally and dispatched once ResumeBinding() is
-  // called.
-  void PauseBinding();
-
-  // Resumes incoming interface request binding.
-  void ResumeBinding();
-
-  // Populates a set with the interface names this registry can bind.
-  void GetInterfaceNames(std::set<std::string>* interface_names);
-
-  // Sets a closure to be run when the InterfaceProvider pipe is closed. Note
-  // that by the time any added closure is invoked, the InterfaceRegistry may
-  // have been deleted.
-  void AddConnectionLostClosure(const base::Closure& connection_lost_closure);
-
-  // Binds a local interface request.
-  void BindInterface(const std::string& name,
-                     mojo::ScopedMessagePipeHandle handle);
-
- private:
-  using InterfaceNameToBinderMap =
-      std::map<std::string, std::unique_ptr<InterfaceBinder>>;
-
-  // mojom::InterfaceProvider:
-  void GetInterface(const std::string& interface_name,
-                    mojo::ScopedMessagePipeHandle handle) override;
-
-  // Returns true if the binder was set, false if it was not set (e.g. by
-  // some filtering policy preventing this interface from being exposed).
-  bool SetInterfaceBinderForName(std::unique_ptr<InterfaceBinder> binder,
-                                 const std::string& name);
-
-  // Returns true if |remote_identity_| is allowed to bind |interface_name|,
-  // according to capability policy.
-  bool CanBindRequestForInterface(const std::string& interface_name) const;
-
-  // Called whenever |remote_interface_provider_spec_| changes to rebuild the
-  // contents of |exposed_interfaces_| and |expose_all_interfaces_|.
-  void RebuildExposedInterfaces();
-
-  void OnConnectionError();
-
-  mojom::InterfaceProviderRequest pending_request_;
-
-  mojo::Binding<mojom::InterfaceProvider> binding_;
-
-  std::string name_;
-
-  // Initialized from static metadata in the host service's manifest.
-  Identity local_identity_;
-  InterfaceProviderSpec local_interface_provider_spec_;
-
-  // Initialized from static metadata in the remote service's manifest.
-  Identity remote_identity_;
-  // Initialized from static metadata in the remote service's manifest. May be
-  // mutated after the fact when a capability is dynamically granted via a call
-  // to GrantCapability().
-  InterfaceProviderSpec remote_interface_provider_spec_;
-
-  // Metadata computed whenever |remote_interface_provider_spec_| changes.
-  InterfaceSet exposed_interfaces_;
-  bool expose_all_interfaces_ = false;
-
-  // Contains every interface binder that has been registered with this
-  // InterfaceRegistry. Not all binders may be reachable depending on the
-  // capabilities requested by the remote. Only interfaces in
-  // exposed_interfaces_ may be bound. When |expose_all_interfaces_| is true,
-  // any interface may be bound.
-  InterfaceNameToBinderMap name_to_binder_;
-  Binder default_binder_;
-
-  bool is_paused_ = false;
-
-  // Pending interface requests which can accumulate if GetInterface() is called
-  // while binding is paused.
-  std::queue<std::pair<std::string, mojo::ScopedMessagePipeHandle>>
-      pending_interface_requests_;
-
-  std::list<base::Closure> connection_lost_closures_;
-
-  base::WeakPtrFactory<InterfaceRegistry> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(InterfaceRegistry);
-};
-
-}  // namespace service_manager
-
-#endif  // SERVICES_SERVICE_MANAGER_PUBLIC_CPP_INTERFACE_REGISTRY_H_