Upstream RunBlockingPoolTask().

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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 31 matching lines @@
         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 handle result callbacks for ExecuteScriptAndGetValue.
+// Class used to handle result callbacks for ExecuteScriptAndGetValue.
 class ScriptCallback {
  public:
   ScriptCallback() { }
   virtual ~ScriptCallback() { }
   void ResultCallback(const base::Value* result);
 
   scoped_ptr<base::Value> result() { return result_.Pass(); }
 
  private:
   scoped_ptr<base::Value> result_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptCallback);
 };
 
 void ScriptCallback::ResultCallback(const base::Value* result) {
   if (result)
     result_.reset(result->DeepCopy());
   base::MessageLoop::current()->Quit();
 }
 
+// Monitors if any task is processed by the message loop.
+class TaskObserver : public base::MessageLoop::TaskObserver {
+ public:
+  TaskObserver() : processed_(false) {}
+  virtual ~TaskObserver() {}
+
+  // MessageLoop::TaskObserver overrides.
+  virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  }
+  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+    processed_ = true;
+  }
+
+  // Returns true if any task was processed.
+  bool processed() const { return processed_; }
+
+ private:
+  bool processed_;
+  DISALLOW_COPY_AND_ASSIGN(TaskObserver);
+};
+
 // Adapter that makes a WindowedNotificationObserver::ConditionTestCallback from
 // a WindowedNotificationObserver::ConditionTestCallbackWithoutSourceAndDetails
 // by ignoring the notification source and details.
 bool IgnoreSourceAndDetails(
     const WindowedNotificationObserver::
         ConditionTestCallbackWithoutSourceAndDetails& callback,
     const NotificationSource& source,
     const NotificationDetails& details) {
   return callback.Run();
 }
@@ skipping 39 matching lines @@
     return;
   }
 
   base::RunLoop run_loop;
   BrowserThread::PostTask(thread_id, FROM_HERE,
       base::Bind(&RunAllPendingMessageAndSendQuit, current_thread_id,
                  run_loop.QuitClosure()));
   RunThisRunLoop(&run_loop);
 }
 
+void RunAllBlockingPoolTasksUntilIdle() {
+  while (true) {
+    TaskObserver task_observer;

[hashimoto, 2014/07/15 05:49:40]

nit: task_observer should be declared and initialized just before
AddTaskObserver().

[mtomasz, 2014/07/15 05:59:16]

Done.

+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+
+    base::MessageLoop::current()->AddTaskObserver(&task_observer);
+    base::RunLoop().RunUntilIdle();
+    base::MessageLoop::current()->RemoveTaskObserver(&task_observer);
+
+    if (!task_observer.processed())
+      break;
+  }
+}
+
 base::Closure GetQuitTaskForRunLoop(base::RunLoop* run_loop) {
   return base::Bind(&DeferredQuitRunLoop, run_loop->QuitClosure(),
                     kNumQuitDeferrals);
 }
 
 scoped_ptr<base::Value> ExecuteScriptAndGetValue(
     RenderFrameHost* render_frame_host, const std::string& script) {
   ScriptCallback observer;
 
   render_frame_host->ExecuteJavaScript(
@@ skipping 126 matching lines @@
 void InProcessUtilityThreadHelper::BrowserChildProcessHostDisconnected(
     const ChildProcessData& data) {
   if (--child_thread_count_)
     return;
 
   if (runner_.get())
     runner_->Quit();
 }
 
 }  // namespace content