Support early associated interface binding on ChannelMojo

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 171 matching lines @@
   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. This must only be called after the listener's
-  // OnChannelConnected is called.
+  // 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.
-  // Must only be called after the listener's OnChannelConnected is called.
   template <typename Interface>
   void GetRemoteAssociatedInterface(
       mojo::AssociatedInterfacePtr<Interface>* proxy) {
     mojo::AssociatedInterfaceRequest<Interface> request =
         mojo::GetProxy(proxy, GetAssociatedGroup());
     GetGenericRemoteAssociatedInterface(Interface::Name_, request.PassHandle());
   }
 
 #if defined(ENABLE_IPC_FUZZER)
   void set_outgoing_message_filter(OutgoingMessageFilter* filter) {
@@ skipping 11 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_NACL_SFI)
   // Calls through to the underlying channel's methods.
   int GetClientFileDescriptor();
   base::ScopedFD TakeClientFileDescriptor();
 #endif
 
  protected:
   class Context;
   // A subclass uses this constructor if it needs to add more information
   // to the internal state.
-  ChannelProxy(Context* context);
+  explicit ChannelProxy(Context* context);
 
 
   // Used internally to hold state that is referenced on the IPC thread.
   class Context : public base::RefCountedThreadSafe<Context>,
                   public Listener {
    public:
     Context(Listener* listener,
             const scoped_refptr<base::SingleThreadTaskRunner>& ipc_thread);
     void ClearIPCTaskRunner();
     base::SingleThreadTaskRunner* ipc_task_runner() const {
@@ skipping 60 matching lines @@
 
     // Methods called on the listener thread.
     void AddFilter(MessageFilter* filter);
     void OnDispatchConnected();
     void OnDispatchError();
     void OnDispatchBadMessage(const Message& message);
 
     void SendFromThisThread(Message* message);
     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_;
 
     // Note, channel_ may be set on the Listener thread or the IPC thread.
     // But once it has been set, it must only be read or cleared on the IPC
     // thread.
@@ skipping 21 matching lines @@
 
     // 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_;
 
     // Whether this channel is used as an endpoint for sending and receiving
     // brokerable attachment messages to/from the broker process.
     bool attachment_broker_endpoint_;
 
-    // Modified only on the listener's thread before Init() is called.
-    std::map<std::string, GenericAssociatedInterfaceFactory>
-        io_thread_interfaces_;
-    std::map<std::string, GenericAssociatedInterfaceFactory>
-        proxy_thread_interfaces_;
+    mojo::AssociatedGroup associated_group_;
 
-    // Valid and constant any time after the ChannelProxy's Listener receives
-    // OnChannelConnected on its own thread.
-    std::unique_ptr<mojo::AssociatedGroup> channel_associated_group_;
+    // Holds associated interface binders added by AddGenericAssociatedInterface
+    // or AddGenericAssociatedInterfaceForIOThread until the underlying channel
+    // has been initialized.
+    base::Lock pending_interfaces_lock_;
+    std::vector<std::pair<std::string, GenericAssociatedInterfaceFactory>>
+        pending_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_