Do not run a nested loop in content::DeferredQuitRunLoop.

content/public/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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 
 // Number of times to repost a Quit task so that the MessageLoop finishes up
 // pending tasks and tasks posted by those pending tasks without risking the
 // potential hang behavior of MessageLoop::QuitWhenIdle.
 // The criteria for choosing this number: it should be high enough to make the
 // quit act like QuitWhenIdle, while taking into account that any page which is
 // animating may be rendering another frame for each quit deferral. For an
 // animating page, the potential delay to quitting the RunLoop would be
 // kNumQuitDeferrals * frame_render_time. Some perf tests run slow, such as
 // 200ms/frame.
-static const int kNumQuitDeferrals = 10;
+constexpr int kNumQuitDeferrals = 10;
 
-static void DeferredQuitRunLoop(const base::Closure& quit_task,
-                                int num_quit_deferrals) {
+void DeferredQuitRunLoop(const base::Closure& quit_task,
+                         int num_quit_deferrals) {
   if (num_quit_deferrals <= 0) {
     quit_task.Run();
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&DeferredQuitRunLoop, quit_task, num_quit_deferrals - 1));
   }
 }
 
-void RunAllPendingMessageAndSendQuit(BrowserThread::ID thread_id,
-                                     const base::Closure& quit_task) {
-  RunAllPendingInMessageLoop();
-  BrowserThread::PostTask(thread_id, FROM_HERE, quit_task);
-}
-
 // Class used to handle result callbacks for ExecuteScriptAndGetValue.
 class ScriptCallback {
  public:
   ScriptCallback() { }
   virtual ~ScriptCallback() { }
   void ResultCallback(const base::Value* result);
 
   std::unique_ptr<base::Value> result() { return std::move(result_); }
 
  private:
@@ skipping 55 matching lines @@
   TestLauncherDelegate* delegate = NULL;
   delegate = GetCurrentTestLauncherDelegate();
   if (delegate)
     delegate->PreRunMessageLoop(run_loop);
   run_loop->Run();
   if (delegate)
     delegate->PostRunMessageLoop();
 }
 
 void RunAllPendingInMessageLoop() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, GetQuitTaskForRunLoop(&run_loop));
   RunThisRunLoop(&run_loop);
 }
 
 void RunAllPendingInMessageLoop(BrowserThread::ID thread_id) {
-  if (BrowserThread::CurrentlyOn(thread_id)) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (thread_id == BrowserThread::UI) {
     RunAllPendingInMessageLoop();
     return;
   }
-  BrowserThread::ID current_thread_id;
-  if (!BrowserThread::GetCurrentThreadIdentifier(&current_thread_id)) {
-    NOTREACHED();
-    return;
-  }
 
+  // Post a DeferredQuitRunLoop() task to |thread_id|. Then, run a RunLoop on
+  // this thread. When a few generations of pending tasks have run on
+  // |thread_id|, a task will be posted to this thread to exit the RunLoop.
   base::RunLoop run_loop;
-  BrowserThread::PostTask(thread_id, FROM_HERE,
-      base::Bind(&RunAllPendingMessageAndSendQuit, current_thread_id,
-                 run_loop.QuitClosure()));
+  const base::Closure post_quit_run_loop_to_ui_thread = base::Bind(
+      base::IgnoreResult(&base::SingleThreadTaskRunner::PostTask),
+      base::ThreadTaskRunnerHandle::Get(), FROM_HERE, run_loop.QuitClosure());
+  BrowserThread::PostTask(
+      thread_id, FROM_HERE,
+      base::Bind(&DeferredQuitRunLoop, post_quit_run_loop_to_ui_thread,
+                 kNumQuitDeferrals));
   RunThisRunLoop(&run_loop);
 }
 
 void RunAllBlockingPoolTasksUntilIdle() {
   while (true) {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
 
     TaskObserver task_observer;
     base::MessageLoop::current()->AddTaskObserver(&task_observer);
     base::RunLoop().RunUntilIdle();
@@ skipping 211 matching lines @@
 
 void WebContentsDestroyedWatcher::Wait() {
   message_loop_runner_->Run();
 }
 
 void WebContentsDestroyedWatcher::WebContentsDestroyed() {
   message_loop_runner_->Quit();
 }
 
 }  // namespace content