Separate Remote InterfaceProvider again, and add a new client lib type for it.

services/shell/public/cpp/interface_registry.h

 // 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_SHELL_PUBLIC_CPP_INTERFACE_REGISTRY_H_
 #define SERVICES_SHELL_PUBLIC_CPP_INTERFACE_REGISTRY_H_
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
@@ skipping 33 matching lines @@
    public:
     explicit TestApi(InterfaceRegistry* registry) : registry_(registry) {}
     ~TestApi() {}
 
     void SetInterfaceBinderForName(InterfaceBinder* binder,
                                    const std::string& interface_name) {
       registry_->SetInterfaceBinderForName(
           base::WrapUnique(binder), interface_name);
     }
 
-    void RemoveInterfaceBinderForName(const std::string& interface_name) {
-      registry_->RemoveInterfaceBinderForName(interface_name);
-    }
-
    private:
     InterfaceRegistry* registry_;
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
   // Construct with a Connection (which may be null), and create an
   // InterfaceProvider pipe, the client end of which may be obtained by calling
   // TakeClientHandle(). If |connection| is non-null, the Mojo Shell's
   // rules filtering which interfaces are allowed to be exposed to clients are
   // imposed on this registry. If null, they are not.
   explicit InterfaceRegistry(Connection* connection);
   // Construct with an InterfaceProviderRequest and a Connection (which may be
   // null, see note above about filtering).
-  InterfaceRegistry(mojom::InterfaceProviderPtr remote_interfaces,
-                    mojom::InterfaceProviderRequest local_interfaces_request,
+  InterfaceRegistry(mojom::InterfaceProviderRequest local_interfaces_request,
                     Connection* connection);
   ~InterfaceRegistry() override;
 
   // Takes the client end of the InterfaceProvider pipe created in the
   // constructor.
   mojom::InterfaceProviderPtr TakeClientHandle();

[Ken Rockot(use gerrit already), 2016/06/16 23:48:58]

Given that you're adding a Bind method, let's get rid of client_handle_ and this
method.

 
-  // Returns a raw pointer to the remote InterfaceProvider.
-  mojom::InterfaceProvider* GetRemoteInterfaces();
-
-  // Sets a closure to be run when the remote InterfaceProvider pipe is closed.
-  void SetRemoteInterfacesConnectionLostClosure(
-      const base::Closure& connection_lost_closure);
+  void Bind(mojom::InterfaceProviderRequest local_interfaces_request);

[Ken Rockot(use gerrit already), 2016/06/16 23:48:58]

nit: Document this, specifically worth noting that this replaces the binding
that was established by the constructor, if any. Or maybe it should just DCHECK
and only be usable if the constructor didn't bind. Your call.

 
   // 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::WrapUnique(
             new 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::WrapUnique(
             new internal::CallbackBinder<Interface>(callback, task_runner)),
         Interface::Name_);
   }
 
-  // Binds |ptr| to an implementation of Interface in the remote application.
-  // |ptr| can immediately be used to start sending requests to the remote
-  // interface.
   template <typename Interface>
-  void GetInterface(mojo::InterfacePtr<Interface>* ptr) {
-    mojo::MessagePipe pipe;
-    ptr->Bind(mojo::InterfacePtrInfo<Interface>(std::move(pipe.handle0), 0u));
-
-    // Local binders can be registered via TestApi.
-    auto it = name_to_binder_.find(Interface::Name_);
-    if (it != name_to_binder_.end()) {
-      it->second->BindInterface(connection_, Interface::Name_,
-                                std::move(pipe.handle1));
-      return;
-    }
-    remote_interfaces_->GetInterface(Interface::Name_, std::move(pipe.handle1));
+  void RemoveInterface() {
+    RemoveInterface(Interface::Name_);
   }
+  void RemoveInterface(const std::string& name);
 
  private:
   using NameToInterfaceBinderMap =
       std::map<std::string, std::unique_ptr<InterfaceBinder>>;
 
   // mojom::InterfaceProvider:
   void GetInterface(const mojo::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);
 
-  void RemoveInterfaceBinderForName(const std::string& interface_name);
-
   mojom::InterfaceProviderPtr client_handle_;
   mojo::Binding<mojom::InterfaceProvider> binding_;
   Connection* connection_;
 
   NameToInterfaceBinderMap name_to_binder_;
 
-  mojom::InterfaceProviderPtr remote_interfaces_;
-
   DISALLOW_COPY_AND_ASSIGN(InterfaceRegistry);
 };
 
 }  // namespace shell
 
 #endif  // SERVICES_SHELL_PUBLIC_CPP_INTERFACE_REGISTRY_H_