Remove associated interface registration from ChannelProxy

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>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel_factory.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
 #include "ipc/message_filter_router.h"
 
 namespace IPC {
 
-namespace {
-
-void BindAssociatedInterfaceOnTaskRunner(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    const ChannelProxy::GenericAssociatedInterfaceFactory& factory,
-    mojo::ScopedInterfaceEndpointHandle handle) {
-  task_runner->PostTask(FROM_HERE, base::Bind(factory, base::Passed(&handle)));
-}
-
-}  // namespace
-
 //------------------------------------------------------------------------------
 
 ChannelProxy::Context::Context(
     Listener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner)
     : listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       listener_(listener),
       ipc_task_runner_(ipc_task_runner),
       channel_connected_called_(false),
       message_filter_router_(new MessageFilterRouter()),
@@ skipping 23 matching lines @@
   DCHECK(!channel_);
   DCHECK_EQ(factory->GetIPCTaskRunner(), ipc_task_runner_);
   channel_ = factory->BuildChannel(this);
 
   Channel::AssociatedInterfaceSupport* support =
       channel_->GetAssociatedInterfaceSupport();
   if (support) {
     associated_group_ = *support->GetAssociatedGroup();
 
     base::AutoLock l(pending_filters_lock_);
-    for (auto& entry : pending_interfaces_)
+    for (auto& entry : pending_io_thread_interfaces_)
       support->AddGenericAssociatedInterface(entry.first, entry.second);
-    pending_interfaces_.clear();
+    pending_io_thread_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 284 matching lines @@
   if (listener_)
     listener_->OnAssociatedInterfaceRequest(interface_name, std::move(handle));
 }
 
 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);
+    pending_io_thread_interfaces_.emplace_back(name, factory);
     return;
   }
   Channel::AssociatedInterfaceSupport* support =
       channel_->GetAssociatedInterfaceSupport();
   if (support)
     support->AddGenericAssociatedInterface(name, factory);
 }
 
 void ChannelProxy::Context::Send(Message* message) {
   ipc_task_runner()->PostTask(
@@ skipping 162 matching lines @@
 }
 
 void ChannelProxy::RemoveFilter(MessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   context_->ipc_task_runner()->PostTask(
       FROM_HERE, base::Bind(&Context::OnRemoveFilter, context_,
                             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) {
   context()->AddGenericAssociatedInterfaceForIOThread(name, factory);
 }
 
 mojo::AssociatedGroup* ChannelProxy::GetAssociatedGroup() {
   return context()->associated_group();
 }
 
@@ skipping 11 matching lines @@
 
   context()->ClearIPCTaskRunner();
 }
 
 void ChannelProxy::OnChannelInit() {
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC