Remove associated interface registration from ChannelProxy

ipc/ipc_channel_proxy.h

 // Copyright (c) 2012 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 IPC_IPC_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 151 matching lines @@
       base::Callback<void(mojo::ScopedInterfaceEndpointHandle)>;
 
   // Adds a generic associated interface factory to bind incoming interface
   // requests directly on the IO thread. MUST be called either before Init() or
   // before the remote end of the Channel is able to send messages (e.g. before
   // its process is launched.)
   void AddGenericAssociatedInterfaceForIOThread(
       const std::string& name,
       const GenericAssociatedInterfaceFactory& factory);
 
-  // Adds a generic associated interface factory to bind incoming interface
-  // requests on the ChannelProxy's thread. MUST be called before Init() or
-  // before the remote end of the Channel is able to send messages (e.g. before
-  // its process is launched.)
-  void AddGenericAssociatedInterface(
-      const std::string& name,
-      const GenericAssociatedInterfaceFactory& factory);
-
   template <typename Interface>
   using AssociatedInterfaceFactory =
       base::Callback<void(mojo::AssociatedInterfaceRequest<Interface>)>;
 
   // Helper to bind an IO-thread associated interface factory, inferring the
   // interface name from the callback argument's type. MUST be called before
   // Init().
   template <typename Interface>
   void AddAssociatedInterfaceForIOThread(
       const AssociatedInterfaceFactory<Interface>& factory) {
     AddGenericAssociatedInterfaceForIOThread(
         Interface::Name_,
         base::Bind(&ChannelProxy::BindAssociatedInterfaceRequest<Interface>,
                    factory));
   }
 
-  // Helper to bind a ChannelProxy-thread associated interface factory,
-  // inferring the interface name from the callback argument's type. MUST be
-  // called before Init().
-  template <typename Interface>
-  void AddAssociatedInterface(
-      const AssociatedInterfaceFactory<Interface>& factory) {
-    AddGenericAssociatedInterface(
-        Interface::Name_,
-        base::Bind(&ChannelProxy::BindAssociatedInterfaceRequest<Interface>,
-                   factory));
-  }
-
   // Gets the AssociatedGroup used to create new associated endpoints on this
   // ChannelProxy.
   mojo::AssociatedGroup* GetAssociatedGroup();
 
   // Requests an associated interface from the remote endpoint.
   void GetGenericRemoteAssociatedInterface(
       const std::string& name,
       mojo::ScopedInterfaceEndpointHandle handle);
 
   // Template helper to request associated interfaces from the remote endpoint.
@@ skipping 116 matching lines @@
     void OnDispatchError();
     void OnDispatchBadMessage(const Message& message);
     void OnDispatchAssociatedInterfaceRequest(
         const std::string& interface_name,
         mojo::ScopedInterfaceEndpointHandle handle);
 
     void ClearChannel();
 
     mojo::AssociatedGroup* associated_group() { return &associated_group_; }
 
-    void AddGenericAssociatedInterface(
-        const std::string& name,
-        const GenericAssociatedInterfaceFactory& factory);
     void AddGenericAssociatedInterfaceForIOThread(
         const std::string& name,
         const GenericAssociatedInterfaceFactory& factory);
 
     scoped_refptr<base::SingleThreadTaskRunner> listener_task_runner_;
     Listener* listener_;
 
     // List of filters.  This is only accessed on the IPC thread.
     std::vector<scoped_refptr<MessageFilter> > filters_;
     scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
@@ skipping 19 matching lines @@
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
 
     // Cached copy of the peer process ID. Set on IPC but read on both IPC and
     // listener threads.
     base::ProcessId peer_pid_;
     base::Lock peer_pid_lock_;
 
     mojo::AssociatedGroup associated_group_;
 
-    // Holds associated interface binders added by AddGenericAssociatedInterface
-    // or AddGenericAssociatedInterfaceForIOThread until the underlying channel
-    // has been initialized.
-    base::Lock pending_interfaces_lock_;
+    // Holds associated interface binders added by
+    // AddGenericAssociatedInterfaceForIOThread until the underlying channel has
+    // been initialized.
+    base::Lock pending_io_thread_interfaces_lock_;
     std::vector<std::pair<std::string, GenericAssociatedInterfaceFactory>>
-        pending_interfaces_;
+        pending_io_thread_interfaces_;
   };
 
   Context* context() { return context_.get(); }
 
 #if defined(ENABLE_IPC_FUZZER)
   OutgoingMessageFilter* outgoing_message_filter() const {
     return outgoing_message_filter_;
   }
 #endif
 
@@ skipping 24 matching lines @@
   bool did_init_;
 
 #if defined(ENABLE_IPC_FUZZER)
   OutgoingMessageFilter* outgoing_message_filter_;
 #endif
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_