chrome: Use base::MessageLoop. (Part 3)

chrome/browser/importer/firefox_importer_unittest_utils_mac.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 "chrome/browser/importer/firefox_importer_unittest_utils.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 67 matching lines @@
       : got_result(false), sender_(NULL) {}
 
   void SetSender(IPC::Sender* sender) {
     sender_ = sender;
   }
 
   void OnInitDecryptorResponse(bool result) {
     DCHECK(!got_result);
     result_bool = result;
     got_result = true;
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   void OnDecryptedTextResonse(const string16& decrypted_text) {
     DCHECK(!got_result);
     result_string = decrypted_text;
     got_result = true;
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   void QuitClient() {
     if (sender_)
       sender_->Send(new Msg_Decryptor_Quit());
   }
 
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(FFDecryptorServerChannelListener, msg)
       IPC_MESSAGE_HANDLER(Msg_Decryptor_InitReturnCode, OnInitDecryptorResponse)
       IPC_MESSAGE_HANDLER(Msg_Decryptor_Response, OnDecryptedTextResonse)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
   // If an error occured, just kill the message Loop.
   virtual void OnChannelError() OVERRIDE {
     got_result = false;
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   // Results of IPC calls.
   string16 result_string;
   bool result_bool;
   // True if IPC call succeeded and data in above variables is valid.
   bool got_result;
 
  private:
   IPC::Sender* sender_;  // weak
 };
 
 FFUnitTestDecryptorProxy::FFUnitTestDecryptorProxy()
     : child_process_(0) {
 }
 
 bool FFUnitTestDecryptorProxy::Setup(const base::FilePath& nss_path) {
   // Create a new message loop and spawn the child process.
-  message_loop_.reset(new MessageLoopForIO());
+  message_loop_.reset(new base::MessageLoopForIO());
 
   listener_.reset(new FFDecryptorServerChannelListener());
   channel_.reset(new IPC::Channel(kTestChannelID,
                                   IPC::Channel::MODE_SERVER,
                                   listener_.get()));
   CHECK(channel_->Connect());
   listener_->SetSender(channel_.get());
 
   // Spawn child and set up sync IPC connection.
   bool ret = LaunchNSSDecrypterChildProcess(nss_path,
@@ skipping 12 matching lines @@
   }
 }
 
 // A message_loop task that quits the message loop when invoked, setting cancel
 // causes the task to do nothing when invoked.
 class CancellableQuitMsgLoop : public base::RefCounted<CancellableQuitMsgLoop> {
  public:
   CancellableQuitMsgLoop() : cancelled_(false) {}
   void QuitNow() {
     if (!cancelled_)
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
   }
   bool cancelled_;
 
  private:
   friend class base::RefCounted<CancellableQuitMsgLoop>;
   ~CancellableQuitMsgLoop() {}
 };
 
 // Spin until either a client response arrives or a timeout occurs.
 bool FFUnitTestDecryptorProxy::WaitForClientResponse() {
   // What we're trying to do here is to wait for an RPC message to go over the
   // wire and the client to reply.  If the client does not reply by a given
   // timeout we kill the message loop.
   // The way we do this is to post a CancellableQuitMsgLoop for 3 seconds in
   // the future and cancel it if an RPC message comes back earlier.
   // This relies on the IPC listener class to quit the message loop itself when
   // a message comes in.
   scoped_refptr<CancellableQuitMsgLoop> quit_task(
       new CancellableQuitMsgLoop());
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CancellableQuitMsgLoop::QuitNow, quit_task.get()),
       TestTimeouts::action_max_timeout());
 
   message_loop_->Run();
   bool ret = !quit_task->cancelled_;
   quit_task->cancelled_ = false;
   return ret;
 }
 
@@ skipping 35 matching lines @@
     bool ret = decryptor_.Init(dll_path, db_path);
     sender_->Send(new Msg_Decryptor_InitReturnCode(ret));
   }
 
   void OnDecrypt(std::string crypt) {
     string16 unencrypted_str = decryptor_.Decrypt(crypt);
     sender_->Send(new Msg_Decryptor_Response(unencrypted_str));
   }
 
   void OnQuitRequest() {
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(FFDecryptorClientChannelListener, msg)
       IPC_MESSAGE_HANDLER(Msg_Decryptor_Init, OnDecryptor_Init)
       IPC_MESSAGE_HANDLER(Msg_Decrypt, OnDecrypt)
       IPC_MESSAGE_HANDLER(Msg_Decryptor_Quit, OnQuitRequest)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
   virtual void OnChannelError() OVERRIDE {
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
  private:
   NSSDecryptor decryptor_;
   IPC::Sender* sender_;
 };
 
 // Entry function in child process.
 MULTIPROCESS_IPC_TEST_MAIN(NSSDecrypterChildProcess) {
-  MessageLoopForIO main_message_loop;
+  base::MessageLoopForIO main_message_loop;
   FFDecryptorClientChannelListener listener;
 
   IPC::Channel channel(kTestChannelID, IPC::Channel::MODE_CLIENT, &listener);
   CHECK(channel.Connect());
   listener.SetSender(&channel);
 
   // run message loop
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   return 0;
 }