GTTF: Remove message loop hooks from TestLauncherDelegate

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/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_launcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
+base::LazyInstance<std::vector<RunMessageLoopHook> >::Leaky
+    g_pre_run_message_loop_hooks = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<std::vector<RunMessageLoopHook> >::Leaky
+    g_post_run_message_loop_hooks = LAZY_INSTANCE_INITIALIZER;
+
 // 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;
@@ skipping 40 matching lines @@
 
 void RunMessageLoop() {
   base::RunLoop run_loop;
   RunThisRunLoop(&run_loop);
 }
 
 void RunThisRunLoop(base::RunLoop* run_loop) {
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::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.
-  TestLauncherDelegate* delegate = NULL;
-#if !defined(OS_IOS)
-  delegate = GetCurrentTestLauncherDelegate();
-#endif
-  if (delegate)
-    delegate->PreRunMessageLoop(run_loop);
+  for (size_t i = 0; i < g_pre_run_message_loop_hooks.Get().size(); i++)

[sky, 2013/05/31 19:27:03]

Should this use ObserverList for the case of the list being modified during
notification?

[Paweł Hajdan Jr., 2013/05/31 19:50:15]

Good question.

ObserverList<RunMessageLoopHook>::AddObserver expects RunMessageLoopHook* though
(instead of const RunMessageLoopHook&). I think this creates tricky issues with
ownership, and at least these hooks won't be modified during iteration, so the
current implementation should be safe.

In fact, there are TODOs all over the place to remove it. :)

+    g_pre_run_message_loop_hooks.Get()[i].Run(run_loop);
+
   run_loop->Run();
-  if (delegate)
-    delegate->PostRunMessageLoop();
+
+  for (size_t i = 0; i < g_pre_run_message_loop_hooks.Get().size(); i++)
+    g_post_run_message_loop_hooks.Get()[i].Run(run_loop);
+}
+
+void AddPreRunMessageLoopHook(const RunMessageLoopHook& hook) {
+  g_pre_run_message_loop_hooks.Get().push_back(hook);
+}
+
+void AddPostRunMessageLoopHook(const RunMessageLoopHook& hook) {
+  g_post_run_message_loop_hooks.Get().push_back(hook);
 }
 
 void RunAllPendingInMessageLoop() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   RunMessageLoop();
 }
 
 void RunAllPendingInMessageLoop(BrowserThread::ID thread_id) {
   if (BrowserThread::CurrentlyOn(thread_id)) {
@@ skipping 94 matching lines @@
   details_ = details;
   seen_ = true;
   if (!running_)
     return;
 
   message_loop_runner_->Quit();
   running_ = false;
 }
 
 }  // namespace content