Let IPC::SyncMessageFilter take advantage of thread-safe Send.

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/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_sync_message.h"
 
 namespace IPC {
 
-SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event)
-    : sender_(NULL),
-      listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      shutdown_event_(shutdown_event) {
-}
-
 bool SyncMessageFilter::Send(Message* message) {
   if (!message->is_sync()) {
     {
       base::AutoLock auto_lock(lock_);
-      if (!io_task_runner_.get()) {
+      if (sender_ && is_channel_send_thread_safe_) {
+        sender_->Send(message);
+        return true;
+      } else if (!io_task_runner_.get()) {
         pending_messages_.push_back(message);
         return true;
       }
     }
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SyncMessageFilter::SendOnIOThread, this, message));
     return true;
   }
 
@@ skipping 66 matching lines @@
             (*iter)->deserializer->SerializeOutputParameters(message);
       }
       (*iter)->done_event->Signal();
       return true;
     }
   }
 
   return false;
 }
 
+SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event,
+                                     bool is_channel_send_thread_safe)
+    : sender_(NULL),
+      is_channel_send_thread_safe_(is_channel_send_thread_safe),
+      listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      shutdown_event_(shutdown_event) {
+}
+
 SyncMessageFilter::~SyncMessageFilter() {
 }
 
 void SyncMessageFilter::SendOnIOThread(Message* message) {
   if (sender_) {
     sender_->Send(message);
     return;
   }
 
   if (message->is_sync()) {
     // We don't know which thread sent it, but it doesn't matter, just signal
     // them all.
     SignalAllEvents();
   }
 
   delete message;
 }
 
 void SyncMessageFilter::SignalAllEvents() {
   base::AutoLock auto_lock(lock_);
   for (PendingSyncMessages::iterator iter = pending_sync_messages_.begin();
        iter != pending_sync_messages_.end(); ++iter) {
     (*iter)->done_event->Signal();
   }
 }
 
 }  // namespace IPC