Support early associated interface binding on ChannelMojo

ipc/ipc_channel_proxy.cc

 // 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.
 
 #include "ipc/ipc_channel_proxy.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 61 matching lines @@
 
 void ChannelProxy::Context::CreateChannel(
     std::unique_ptr<ChannelFactory> factory) {
   base::AutoLock l(channel_lifetime_lock_);
   DCHECK(!channel_);
   DCHECK_EQ(factory->GetIPCTaskRunner(), ipc_task_runner_);
   channel_id_ = factory->GetName();
   channel_ = factory->BuildChannel(this);
   channel_send_thread_safe_ = channel_->IsSendThreadSafe();
   channel_->SetAttachmentBrokerEndpoint(attachment_broker_endpoint_);
+
+  Channel::AssociatedInterfaceSupport* support =
+      channel_->GetAssociatedInterfaceSupport();
+  if (support) {
+    associated_group_ = *support->GetAssociatedGroup();
+
+    base::AutoLock l(pending_filters_lock_);
+    for (auto& entry : pending_interfaces_)
+      support->AddGenericAssociatedInterface(entry.first, entry.second);
+    pending_interfaces_.clear();
+  }
 }
 
 bool ChannelProxy::Context::TryFilters(const Message& message) {
   DCHECK(message_filter_router_);
 #ifdef IPC_MESSAGE_LOG_ENABLED
   Logging* logger = Logging::GetInstance();
   if (logger->Enabled())
     logger->OnPreDispatchMessage(message);
 #endif
 
@@ skipping 63 matching lines @@
   // will be released when we are closed.
   AddRef();
 
   if (!channel_->Connect()) {
     OnChannelError();
     return;
   }
 
   for (size_t i = 0; i < filters_.size(); ++i)
     filters_[i]->OnFilterAdded(channel_.get());
-
-  Channel::AssociatedInterfaceSupport* support =
-      channel_->GetAssociatedInterfaceSupport();
-  if (support) {
-    support->SetProxyTaskRunner(listener_task_runner_);
-    for (auto& entry : io_thread_interfaces_)
-      support->AddGenericAssociatedInterface(entry.first, entry.second);
-    for (auto& entry : proxy_thread_interfaces_) {
-      support->AddGenericAssociatedInterface(
-          entry.first, base::Bind(&BindAssociatedInterfaceOnTaskRunner,
-                                  listener_task_runner_, entry.second));
-    }
-  } else {
-    // Sanity check to ensure nobody's expecting to use associated interfaces on
-    // a Channel that doesn't support them.
-    DCHECK(io_thread_interfaces_.empty() && proxy_thread_interfaces_.empty());
-  }
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnChannelClosed() {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 ChannelProxy::Context::OnChannelClosed"));
   // It's okay for IPC::ChannelProxy::Close to be called more than once, which
   // would result in this branch being taken.
@@ skipping 133 matching lines @@
   if (logger->Enabled())
     logger->OnPostDispatchMessage(message, channel_id_);
 #endif
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchConnected() {
   if (channel_connected_called_)
     return;
 
-  {
-    base::AutoLock l(channel_lifetime_lock_);
-    if (channel_) {
-      Channel::AssociatedInterfaceSupport* associated_interface_support =
-          channel_->GetAssociatedInterfaceSupport();
-      if (associated_interface_support) {
-        channel_associated_group_.reset(new mojo::AssociatedGroup(
-            *associated_interface_support->GetAssociatedGroup()));
-      }
-    }
-  }
-
   base::ProcessId peer_pid;
   {
     base::AutoLock l(peer_pid_lock_);
     peer_pid = peer_pid_;
   }
   channel_connected_called_ = true;
   if (listener_)
     listener_->OnChannelConnected(peer_pid);
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchError() {
   if (listener_)
     listener_->OnChannelError();
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchBadMessage(const Message& message) {
   if (listener_)
     listener_->OnBadMessageReceived(message);
 }
 
 void ChannelProxy::Context::ClearChannel() {
   base::AutoLock l(channel_lifetime_lock_);
   channel_.reset();
+  associated_group_ = mojo::AssociatedGroup();
+}
+
+void ChannelProxy::Context::AddGenericAssociatedInterface(
+    const std::string& name,
+    const GenericAssociatedInterfaceFactory& factory) {
+  AddGenericAssociatedInterfaceForIOThread(
+      name, base::Bind(&BindAssociatedInterfaceOnTaskRunner,
+                       listener_task_runner_, factory));
+}
+
+void ChannelProxy::Context::AddGenericAssociatedInterfaceForIOThread(
+    const std::string& name,
+    const GenericAssociatedInterfaceFactory& factory) {
+  base::AutoLock l(channel_lifetime_lock_);
+  if (!channel_) {
+    base::AutoLock l(pending_filters_lock_);
+    pending_interfaces_.emplace_back(name, factory);
+    return;
+  }
+  Channel::AssociatedInterfaceSupport* support =
+      channel_->GetAssociatedInterfaceSupport();
+  DCHECK(support);
+  support->AddGenericAssociatedInterface(name, factory);
 }
 
 void ChannelProxy::Context::SendFromThisThread(Message* message) {
   base::AutoLock l(channel_lifetime_lock_);
   if (!channel_)
     return;
   DCHECK(channel_->IsSendThreadSafe());
   channel_->Send(message);
 }
 
@@ skipping 157 matching lines @@
 }
 
 void ChannelProxy::RemoveFilter(MessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   context_->ipc_task_runner()->PostTask(
       FROM_HERE, base::Bind(&Context::OnRemoveFilter, context_.get(),
                             base::RetainedRef(filter)));
 }
 
+void ChannelProxy::AddGenericAssociatedInterface(
+    const std::string& name,
+    const GenericAssociatedInterfaceFactory& factory) {
+  context()->AddGenericAssociatedInterface(name, factory);
+}
+
 void ChannelProxy::AddGenericAssociatedInterfaceForIOThread(
     const std::string& name,
     const GenericAssociatedInterfaceFactory& factory) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!did_init_);
-  context_->io_thread_interfaces_.insert({ name, factory });
-}
-
-void ChannelProxy::AddGenericAssociatedInterface(
-    const std::string& name,
-    const GenericAssociatedInterfaceFactory& factory) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!did_init_);
-  context_->proxy_thread_interfaces_.insert({ name, factory });
+  context()->AddGenericAssociatedInterfaceForIOThread(name, factory);
 }
 
 mojo::AssociatedGroup* ChannelProxy::GetAssociatedGroup() {
-  return context_->channel_associated_group_.get();
+  return context()->associated_group();
 }
 
 void ChannelProxy::GetGenericRemoteAssociatedInterface(
     const std::string& name,
     mojo::ScopedInterfaceEndpointHandle handle) {
   context_->ipc_task_runner()->PostTask(
       FROM_HERE, base::Bind(&Context::GetRemoteAssociatedInterface,
                             context_.get(), name, base::Passed(&handle)));
 }
 
@@ skipping 34 matching lines @@
   return channel->TakeClientFileDescriptor();
 }
 #endif
 
 void ChannelProxy::OnChannelInit() {
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC