Allow synchronous messages to be sent from threads other than the main thread...

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2006-2008 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.
 //
 // Unit test for SyncChannel.
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/dynamic_annotations.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_channel.h"
+#include "ipc/ipc_sync_message_filter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 
 #define MESSAGES_INTERNAL_FILE "ipc/ipc_sync_message_unittest.h"
 #include "ipc/ipc_message_macros.h"
 
 using namespace IPC;
 using base::WaitableEvent;
 
 namespace {
@@ skipping 82 matching lines @@
     SyncMessage* msg = new SyncChannelTestMsg_Double(5, &answer);
     if (pump)
       msg->EnableMessagePumping();
     bool result = Send(msg);
     DCHECK_EQ(result, succeed);
     DCHECK_EQ(answer, (succeed ? 10 : 0));
     return result;
   }
   Channel::Mode mode() { return mode_; }
   WaitableEvent* done_event() { return done_.get(); }
+  WaitableEvent* shutdown_event() { return &shutdown_event_; }
   void ResetChannel() { channel_.reset(); }
-
- protected:
   // Derived classes need to call this when they've completed their part of
   // the test.
   void Done() { done_->Signal(); }
+
+ protected:
+  IPC::SyncChannel* channel() { return channel_.get(); }
   // Functions for dervied classes to implement if they wish.
   virtual void Run() { }
   virtual void OnAnswer(int* answer) { NOTREACHED(); }
   virtual void OnAnswerDelay(Message* reply_msg) {
     // The message handler map below can only take one entry for
     // SyncChannelTestMsg_AnswerToLife, so since some classes want
     // the normal version while other want the delayed reply, we
     // call the normal version if the derived class didn't override
     // this function.
     int answer;
@@ skipping 908 matching lines @@
 
 // Tests http://b/1474092 - that if after the done_event is set but before
 // OnObjectSignaled is called another message is sent out, then after its
 // reply comes back OnObjectSignaled will be called for the first message.
 TEST_F(IPCSyncChannelTest, DoneEventRace) {
   std::vector<Worker*> workers;
   workers.push_back(new DoneEventRaceServer());
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
+
+//-----------------------------------------------------------------------------
+
+namespace {
+
+class TestSyncMessageFilter : public IPC::SyncMessageFilter {
+ public:
+  TestSyncMessageFilter(base::WaitableEvent* shutdown_event, Worker* worker)
+      : SyncMessageFilter(shutdown_event),
+        worker_(worker),
+        thread_("helper_thread") {
+    base::Thread::Options options;
+    options.message_loop_type = MessageLoop::TYPE_DEFAULT;
+    thread_.StartWithOptions(options);
+  }
+
+  virtual void OnFilterAdded(Channel* channel) {
+    SyncMessageFilter::OnFilterAdded(channel);
+    thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &TestSyncMessageFilter::SendMessageOnHelperThread));
+  }
+
+  void SendMessageOnHelperThread() {
+    int answer = 0;
+    bool result = Send(new SyncChannelTestMsg_AnswerToLife(&answer));
+    DCHECK(result);
+    DCHECK_EQ(answer, 42);
+
+    worker_->Done();
+  }
+
+  Worker* worker_;
+  base::Thread thread_;
+};
+
+class SyncMessageFilterServer : public Worker {
+ public:
+  SyncMessageFilterServer()
+      : Worker(Channel::MODE_SERVER, "sync_message_filter_server") {
+    filter_ = new TestSyncMessageFilter(shutdown_event(), this);
+  }
+
+  void Run() {
+    channel()->AddFilter(filter_.get());
+  }
+
+  scoped_refptr<TestSyncMessageFilter> filter_;
+};
+
+}  // namespace
+
+// Tests basic synchronous call
+TEST_F(IPCSyncChannelTest, SyncMessageFilter) {
+  std::vector<Worker*> workers;
+  workers.push_back(new SyncMessageFilterServer());
+  workers.push_back(new SimpleClient());
+  RunTest(workers);
+}