Move RunAllPendingInMessageLoop from ui_test_utils.h to test_utils.h, so that it can be reused by c…

content/test/test_utils.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 "content/public/test/test_utils.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 16 matching lines @@
 static void DeferredQuitRunLoop(const base::Closure& quit_task,
                                 int num_quit_deferrals) {
   if (num_quit_deferrals <= 0) {
     quit_task.Run();
   } else {
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&DeferredQuitRunLoop, quit_task, num_quit_deferrals - 1));
   }
 }
 
+void RunAllPendingMessageAndSendQuit(BrowserThread::ID thread_id,
+                                     const base::Closure& quit_task) {
+  MessageLoop::current()->PostTask(FROM_HERE,
+                                   MessageLoop::QuitWhenIdleClosure());
+  RunMessageLoop();

[scottmg, 2012/07/30 20:23:26]

Replace 39-41 with content::RunAllPendingInMessageLoop()?

[jam, 2012/07/30 20:34:21]

Done.

+  BrowserThread::PostTask(thread_id, FROM_HERE, quit_task);
 }
 
+}  // namespace
+
 namespace content {
 
 void RunMessageLoop() {
   base::RunLoop run_loop;
   RunThisRunLoop(&run_loop);
 }
 
 void RunThisRunLoop(base::RunLoop* run_loop) {
   MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
 
   // If we're running inside a browser test, we might need to allow the test
   // launcher to do extra work before/after running a nested message loop.
   test_launcher::TestLauncherDelegate* delegate =
       test_launcher::GetCurrentTestLauncherDelegate();
   if (delegate)
     delegate->PreRunMessageLoop(run_loop);
   run_loop->Run();
   if (delegate)
     delegate->PostRunMessageLoop();
 }
 
+void RunAllPendingInMessageLoop() {
+  MessageLoop::current()->PostTask(FROM_HERE,
+                                   MessageLoop::QuitWhenIdleClosure());
+  RunMessageLoop();
+}
+
+void RunAllPendingInMessageLoop(BrowserThread::ID thread_id) {
+  if (BrowserThread::CurrentlyOn(thread_id)) {
+    RunAllPendingInMessageLoop();
+    return;
+  }
+  BrowserThread::ID current_thread_id;
+  if (!BrowserThread::GetCurrentThreadIdentifier(&current_thread_id)) {
+    NOTREACHED();
+    return;
+  }
+
+  base::RunLoop run_loop;
+  BrowserThread::PostTask(thread_id, FROM_HERE,
+      base::Bind(&RunAllPendingMessageAndSendQuit, current_thread_id,
+                 run_loop.QuitClosure()));
+  RunThisRunLoop(&run_loop);
+}
+
 base::Closure GetQuitTaskForRunLoop(base::RunLoop* run_loop) {
   return base::Bind(&DeferredQuitRunLoop, run_loop->QuitClosure(),
                     kNumQuitDeferrals);
 }
 
 MessageLoopRunner::MessageLoopRunner() {
 }
 
 MessageLoopRunner::~MessageLoopRunner() {
 }
@@ skipping 39 matching lines @@
   details_ = details;
   seen_ = true;
   if (!running_)
     return;
 
   message_loop_runner_->Quit();
   running_ = false;
 }
 
 }  // namespace content