Switch MessagePumpForIO to use completion ports on Windows....

chrome/common/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 <windows.h>
 #include <string>
 #include <vector>
 
@@ skipping 86 matching lines @@
   bool Send(Message* msg) { return channel_->Send(msg); }
   bool SendWithTimeout(Message* msg, int timeout_ms) {
     return channel_->SendWithTimeout(msg, timeout_ms);
   }
   void WaitForChannelCreation() { channel_created_.Wait(); }
   void CloseChannel() {
     DCHECK(MessageLoop::current() == ListenerThread()->message_loop());
     channel_->Close();
   }
   void Start() {
-    StartThread(&listener_thread_);
+    StartThread(&listener_thread_, MessageLoop::TYPE_DEFAULT);
     ListenerThread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Worker::OnStart));
   }
   void OverrideThread(base::Thread* overrided_thread) {
     DCHECK(overrided_thread_ == NULL);
     overrided_thread_ = overrided_thread;
   }
   Channel::Mode mode() { return mode_; }
   HANDLE done_event() { return done_.handle(); }
 
@@ skipping 24 matching lines @@
     Send(reply_msg);
   }
 
  private:
   base::Thread* ListenerThread() {
     return overrided_thread_ ? overrided_thread_ : &listener_thread_;
   }
   // Called on the listener thread to create the sync channel.
   void OnStart() {
     // Link ipc_thread_, listener_thread_ and channel_ altogether.
-    StartThread(&ipc_thread_);
+    StartThread(&ipc_thread_, MessageLoop::TYPE_IO);
     channel_.reset(new SyncChannel(
         channel_name_, mode_, this, NULL, ipc_thread_.message_loop(), true,
         TestProcess::GetShutDownEvent()));
     channel_created_.Set();
     Run();
   }
 
   void OnListenerThreadShutdown(HANDLE listener_event, HANDLE ipc_event) {
     // SyncChannel needs to be destructed on the thread that it was created on.
     channel_.reset();
     SetEvent(listener_event);
     
     ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Worker::OnIPCThreadShutdown, ipc_event));
   }
 
   void OnIPCThreadShutdown(HANDLE ipc_event) {
     SetEvent(ipc_event);
   }
 
   void OnMessageReceived(const Message& message) {
     IPC_BEGIN_MESSAGE_MAP(Worker, message)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_Double, OnDoubleDelay)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_AnswerToLife,
                                      OnAnswerDelay)
     IPC_END_MESSAGE_MAP()
   }
 
-  void StartThread(base::Thread* thread) {
+  void StartThread(base::Thread* thread, MessageLoop::Type type) {
     base::Thread::Options options;
-    options.message_loop_type = MessageLoop::TYPE_IO;
+    options.message_loop_type = type;
     thread->StartWithOptions(options);
   }
 
   Event done_;
   Event channel_created_;
   std::wstring channel_name_;
   Channel::Mode mode_;
   scoped_ptr<SyncChannel> channel_;
   base::Thread ipc_thread_;
   base::Thread listener_thread_;
@@ skipping 820 matching lines @@
 TEST_F(IPCSyncChannelTest, SendWithTimeoutTimeout) {
   SendWithTimeoutTimeout(false);
   SendWithTimeoutTimeout(true);
 }
 
 // Sends some message that time-out and some that succeed.
 TEST_F(IPCSyncChannelTest, SendWithTimeoutMixedOKAndTimeout) {
   SendWithTimeoutMixedOKAndTimeout(false);
   SendWithTimeoutMixedOKAndTimeout(true);
 }