IPC: Delete thread-safe send support

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 29 matching lines @@
 
 //------------------------------------------------------------------------------
 
 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),
-      channel_send_thread_safe_(false),
       message_filter_router_(new MessageFilterRouter()),
       peer_pid_(base::kNullProcessId),
       attachment_broker_endpoint_(false) {
   DCHECK(ipc_task_runner_.get());
   // The Listener thread where Messages are handled must be a separate thread
   // to avoid oversubscribing the IO thread. If you trigger this error, you
   // need to either:
   // 1) Create the ChannelProxy on a different thread, or
   // 2) Just use Channel
   // Note, we currently make an exception for a NULL listener. That usage
   // basically works, but is outside the intent of ChannelProxy. This support
   // will disappear, so please don't rely on it. See crbug.com/364241
   DCHECK(!listener || (ipc_task_runner_.get() != listener_task_runner_.get()));
 }
 
 ChannelProxy::Context::~Context() {
 }
 
 void ChannelProxy::Context::ClearIPCTaskRunner() {
   ipc_task_runner_ = NULL;
 }
 
 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);
@@ skipping 314 matching lines @@
     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);
-}
-
 void ChannelProxy::Context::Send(Message* message) {
-  if (channel_send_thread_safe_) {
-    SendFromThisThread(message);
-    return;
-  }
-
   ipc_task_runner()->PostTask(
       FROM_HERE, base::Bind(&ChannelProxy::Context::OnSendMessage, this,
                             base::Passed(base::WrapUnique(message))));
 }
 
-bool ChannelProxy::Context::IsChannelSendThreadSafe() const {
-  return channel_send_thread_safe_;
-}
-
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::GetRemoteAssociatedInterface(
     const std::string& name,
     mojo::ScopedInterfaceEndpointHandle handle) {
   if (!channel_)
     return;
   Channel::AssociatedInterfaceSupport* associated_interface_support =
       channel_->GetAssociatedInterfaceSupport();
   DCHECK(associated_interface_support);
   associated_interface_support->GetGenericRemoteAssociatedInterface(
@@ skipping 217 matching lines @@
   return channel->TakeClientFileDescriptor();
 }
 #endif
 
 void ChannelProxy::OnChannelInit() {
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC