IPC: Delete thread-safe send support

ipc/ipc_sync_message_filter.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_sync_message_filter.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 81 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> filter_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(IOMessageLoopObserver);
 };
 
 bool SyncMessageFilter::Send(Message* message) {
   if (!message->is_sync()) {
     {
       base::AutoLock auto_lock(lock_);
-      if (sender_ && is_channel_send_thread_safe_) {
-        sender_->Send(message);
-        return true;
-      } else if (!io_task_runner_.get()) {
+      if (!io_task_runner_.get()) {
         pending_messages_.emplace_back(base::WrapUnique(message));
         return true;
       }
     }
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SyncMessageFilter::SendOnIOThread, this, message));
     return true;
   }
 
@@ skipping 97 matching lines @@
                               "SyncMessageFilter::OnMessageReceived",
                               (*iter)->done_event);
       (*iter)->done_event->Signal();
       return true;
     }
   }
 
   return false;
 }
 
-SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event,
-                                     bool is_channel_send_thread_safe)
+SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event)
     : sender_(NULL),
-      is_channel_send_thread_safe_(is_channel_send_thread_safe),
       listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       shutdown_event_(shutdown_event),
       weak_factory_(this) {
   io_message_loop_observer_ = new IOMessageLoopObserver(
       weak_factory_.GetWeakPtr(), listener_task_runner_);
 }
 
 SyncMessageFilter::~SyncMessageFilter() {
   io_message_loop_observer_->Stop();
 }
@@ skipping 32 matching lines @@
 
 void SyncMessageFilter::OnIOMessageLoopDestroyed() {
   // Since we use an async WaitableEventWatcher to watch the shutdown event
   // from the IO thread, we can't forward the shutdown signal after the IO
   // message loop is destroyed. Since that destruction indicates shutdown
   // anyway, we manually signal the shutdown event in this case.
   shutdown_mojo_event_.Signal();
 }
 
 }  // namespace IPC