Remove calls to MessageLoop::Run/RunUntilIdle.

chrome/utility/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/utility/importer/firefox_importer_unittest_utils.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 161 matching lines @@
   listener_->QuitClient();
   channel_->Close();
 
   if (child_process_.IsValid()) {
     int exit_code;
     child_process_.WaitForExitWithTimeout(base::TimeDelta::FromSeconds(5),
                                           &exit_code);
   }
 }
 
-// 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_)
-      base::MessageLoop::current()->QuitWhenIdle();
-  }
-  bool cancelled_;
-
- private:
-  friend class base::RefCounted<CancellableQuitMsgLoop>;
-  ~CancellableQuitMsgLoop() {}
-};
-
 // Spin until either a client response arrives or a timeout occurs.
-bool FFUnitTestDecryptorProxy::WaitForClientResponse() {
+void 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());
+  base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancellableQuitMsgLoop::QuitNow, quit_task.get()),
+      FROM_HERE, run_loop.QuitWhenIdleClosure(),
       TestTimeouts::action_max_timeout());
-
-  message_loop_->Run();
-  bool ret = !quit_task->cancelled_;
-  quit_task->cancelled_ = false;
-  return ret;
+  run_loop.Run();
 }
 
 bool FFUnitTestDecryptorProxy::DecryptorInit(const base::FilePath& dll_path,
                                              const base::FilePath& db_path) {
   channel_->Send(new Msg_Decryptor_Init(dll_path, db_path));
-  bool ok = WaitForClientResponse();
-  if (ok && listener_->got_result) {
+  WaitForClientResponse();
+  if (listener_->got_result) {
     listener_->got_result = false;
     return listener_->result_bool;
   }
   return false;
 }
 
 base::string16 FFUnitTestDecryptorProxy::Decrypt(const std::string& crypt) {
   channel_->Send(new Msg_Decrypt(crypt));
-  bool ok = WaitForClientResponse();
-  if (ok && listener_->got_result) {
+  WaitForClientResponse();
+  if (listener_->got_result) {
     listener_->got_result = false;
     return listener_->result_string;
   }
   return base::string16();
 }
 
 std::vector<autofill::PasswordForm> FFUnitTestDecryptorProxy::ParseSignons(
     const base::FilePath& signons_path) {
   channel_->Send(new Msg_ParseSignons(signons_path));
-  bool ok = WaitForClientResponse();
-  if (ok && listener_->got_result) {
+  WaitForClientResponse();
+  if (listener_->got_result) {
     listener_->got_result = false;
     return listener_->result_vector;
   }
   return std::vector<autofill::PasswordForm>();
 }
 
 //---------------------------- Child Process -----------------------
 
 // Class to listen on the client side of the ipc channel, it calls through
 // to the NSSDecryptor and sends back a reply.
@@ skipping 61 matching lines @@
   std::unique_ptr<IPC::Channel> channel =
       IPC::Channel::CreateClient(mojo_handle.release(), &listener);
   CHECK(channel->Connect());
   listener.SetSender(channel.get());
 
   // run message loop
   base::RunLoop().Run();
 
   return 0;
 }