ipc: Use base::MessageLoop.

ipc/ipc_fuzzing_tests.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 <stdio.h>
 #include <string>
 #include <sstream>
 
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
@@ skipping 157 matching lines @@
                                              IPC::Message::PRIORITY_NORMAL);
     message->WriteInt(reply + 1);
     message->WriteInt(reply);
     return other_->Send(message);
   }
 
   void Cleanup() {
     --message_count_;
     --pending_messages_;
     if (0 == message_count_)
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
   }
 
   void ReplyMsgNotHandled(uint32 type_id) {
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgUnhandled::ID, type_id);
     Cleanup();
   }
 
   void UseData(int caller, int value, const std::wstring& text) {
     std::wostringstream wos;
     wos << L"IPC fuzzer:" << caller << " [" << value << L" " << text << L"]\n";
     std::wstring output = wos.str();
     LOG(WARNING) << output.c_str();
   };
 
   int message_count_;
   int pending_messages_;
 };
 
 class FuzzerClientListener : public SimpleListener {
  public:
   FuzzerClientListener() : last_msg_(NULL) {
   }
 
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
     last_msg_ = new IPC::Message(msg);
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
     return true;
   }
 
   bool ExpectMessage(int value, uint32 type_id) {
     if (!MsgHandlerInternal(type_id))
       return false;
     int msg_value1 = 0;
     int msg_value2 = 0;
     PickleIterator iter(*last_msg_);
     if (!last_msg_->ReadInt(&iter, &msg_value1))
       return false;
     if (!last_msg_->ReadInt(&iter, &msg_value2))
       return false;
     if ((msg_value2 + 1) != msg_value1)
       return false;
     if (msg_value2 != value)
       return false;
 
     delete last_msg_;
     last_msg_ = NULL;
     return true;
   }
 
   bool ExpectMsgNotHandled(uint32 type_id) {
     return ExpectMessage(type_id, MsgUnhandled::ID);
   }
 
  private:
   bool MsgHandlerInternal(uint32 type_id) {
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
     if (NULL == last_msg_)
       return false;
     if (FUZZER_ROUTING_ID != last_msg_->routing_id())
       return false;
     return (type_id == last_msg_->type());
   };
 
   IPC::Message* last_msg_;
 };
 
 // Runs the fuzzing server child mode. Returns when the preset number of
 // messages have been received.
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(FuzzServerClient) {
-  MessageLoopForIO main_message_loop;
+  base::MessageLoopForIO main_message_loop;
   FuzzerServerListener listener;
   IPC::Channel channel(IPCTestBase::GetChannelName("FuzzServerClient"),
                        IPC::Channel::MODE_CLIENT,
                        &listener);
   CHECK(channel.Connect());
   listener.Init(&channel);
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
   return 0;
 }
 
 class IPCFuzzingTest : public IPCTestBase {
 };
 
 // This test makes sure that the FuzzerClientListener and FuzzerServerListener
 // are working properly by generating two well formed IPC calls.
 TEST_F(IPCFuzzingTest, SanityTest) {
   Init("FuzzServerClient");
@@ skipping 138 matching lines @@
   msg->WriteInt(0x64);
   msg->WriteInt(0x32);
   EXPECT_FALSE(server.OnMessageReceived(*msg));
   delete msg;
 
   EXPECT_EQ(0, server.unhandled_msgs());
 #endif
 }
 
 }  // namespace