Get content_browsertest working. I've added a simple test for now, and will convert the tests in sr…

chrome/test/base/ui_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 "chrome/test/base/ui_test_utils.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 45 matching lines @@
 #include "content/public/browser/geolocation.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/geoposition.h"
+#include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "net/test/python_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/size.h"
 #include "ui/ui_controls/ui_controls.h"
 
-#if defined(TOOLKIT_VIEWS)
-#include "ui/views/focus/accelerator_handler.h"
-#endif
-
 #if defined(USE_AURA)
 #include "ash/shell.h"
 #include "ui/aura/root_window.h"
 #endif
 
 using content::DomOperationNotificationDetails;
 using content::NativeWebKeyboardEvent;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::Referrer;
 using content::WebContents;
 
 static const int kDefaultWsPort = 8880;
 
-// 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;
-
 namespace ui_test_utils {
 
 namespace {
 
 class DOMOperationObserver : public content::NotificationObserver,
                              public content::WebContentsObserver {
  public:
   explicit DOMOperationObserver(RenderViewHost* render_view_host)
       : content::WebContentsObserver(
             WebContents::FromRenderViewHost(render_view_host)),
@@ skipping 166 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE,
                                    MessageLoop::QuitWhenIdleClosure());
   RunMessageLoop();
   content::BrowserThread::PostTask(thread_id, FROM_HERE, quit_task);
 }
 
 }  // namespace
 
 void RunMessageLoop() {
   base::RunLoop run_loop;
-  RunThisRunLoop(&run_loop);
-}
-
-void RunThisRunLoop(base::RunLoop* run_loop) {
-  MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
-#if !defined(USE_AURA) && defined(TOOLKIT_VIEWS)
-  scoped_ptr<views::AcceleratorHandler> handler;
-  if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
-    handler.reset(new views::AcceleratorHandler);
-    run_loop->set_dispatcher(handler.get());
-  }
-#endif
-  run_loop->Run();
-}
-
-// TODO(jbates) move this to a new test_utils.cc in content/test/
-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));
-  }
-}
-
-base::Closure GetQuitTaskForRunLoop(base::RunLoop* run_loop) {
-  return base::Bind(&DeferredQuitRunLoop, run_loop->QuitClosure(),
-                    kNumQuitDeferrals);
+  content::RunThisRunLoop(&run_loop);
 }
 
 void RunAllPendingInMessageLoop() {
   MessageLoop::current()->PostTask(FROM_HERE,
                                    MessageLoop::QuitWhenIdleClosure());
   ui_test_utils::RunMessageLoop();
 }
 
 void RunAllPendingInMessageLoop(content::BrowserThread::ID thread_id) {
   if (content::BrowserThread::CurrentlyOn(thread_id)) {
     RunAllPendingInMessageLoop();
     return;
   }
   content::BrowserThread::ID current_thread_id;
   if (!content::BrowserThread::GetCurrentThreadIdentifier(&current_thread_id)) {
     NOTREACHED();
     return;
   }
 
   base::RunLoop run_loop;
   content::BrowserThread::PostTask(thread_id, FROM_HERE,
       base::Bind(&RunAllPendingMessageAndSendQuit, current_thread_id,
                  run_loop.QuitClosure()));
-  ui_test_utils::RunThisRunLoop(&run_loop);
+  content::RunThisRunLoop(&run_loop);
 }
 
 bool GetCurrentTabTitle(const Browser* browser, string16* title) {
   WebContents* web_contents = chrome::GetActiveWebContents(browser);
   if (!web_contents)
     return false;
   NavigationEntry* last_entry = web_contents->GetController().GetActiveEntry();
   if (!last_entry)
     return false;
   title->assign(last_entry->GetTitleForDisplay(""));
   return true;
 }
 
 void WaitForNavigations(NavigationController* controller,
                         int number_of_navigations) {
   content::TestNavigationObserver observer(
       content::Source<NavigationController>(controller), NULL,
       number_of_navigations);
   base::RunLoop run_loop;
   observer.WaitForObservation(
-      base::Bind(&ui_test_utils::RunThisRunLoop, base::Unretained(&run_loop)),
-      ui_test_utils::GetQuitTaskForRunLoop(&run_loop));
+      base::Bind(&content::RunThisRunLoop, base::Unretained(&run_loop)),
+      content::GetQuitTaskForRunLoop(&run_loop));
 }
 
 void WaitForNewTab(Browser* browser) {
   WindowedNotificationObserver observer(
       chrome::NOTIFICATION_TAB_ADDED,
       content::Source<content::WebContentsDelegate>(browser));
   observer.Wait();
 }
 
 void WaitForLoadStop(WebContents* tab) {
@@ skipping 26 matching lines @@
                      1);
   return browser;
 }
 
 void NavigateToURL(chrome::NavigateParams* params) {
   content::TestNavigationObserver observer(
       content::NotificationService::AllSources(), NULL, 1);
   chrome::Navigate(params);
   base::RunLoop run_loop;
   observer.WaitForObservation(
-      base::Bind(&ui_test_utils::RunThisRunLoop, base::Unretained(&run_loop)),
-      ui_test_utils::GetQuitTaskForRunLoop(&run_loop));
+      base::Bind(&content::RunThisRunLoop, base::Unretained(&run_loop)),
+      content::GetQuitTaskForRunLoop(&run_loop));
 }
 
 void NavigateToURL(Browser* browser, const GURL& url) {
   NavigateToURLWithDisposition(browser, url, CURRENT_TAB,
                                BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 // Navigates the specified tab (via |disposition|) of |browser| to |url|,
 // blocking until the |number_of_navigations| specified complete.
 // |disposition| indicates what tab the download occurs in, and
@@ skipping 52 matching lines @@
     return;
   } else if ((disposition == CURRENT_TAB) ||
       (disposition == NEW_FOREGROUND_TAB) ||
       (disposition == SINGLETON_TAB)) {
     // The currently selected tab is the right one.
     web_contents = chrome::GetActiveWebContents(browser);
   }
   if (disposition == CURRENT_TAB) {
     base::RunLoop run_loop;
     same_tab_observer.WaitForObservation(
-        base::Bind(&ui_test_utils::RunThisRunLoop, base::Unretained(&run_loop)),
-        ui_test_utils::GetQuitTaskForRunLoop(&run_loop));
+        base::Bind(&content::RunThisRunLoop, base::Unretained(&run_loop)),
+        content::GetQuitTaskForRunLoop(&run_loop));
     return;
   } else if (web_contents) {
     NavigationController* controller = &web_contents->GetController();
     WaitForNavigations(controller, number_of_navigations);
     return;
   }
   EXPECT_TRUE(NULL != web_contents) << " Unable to wait for navigation to \""
                                     << url.spec() << "\""
                                     << " because we can't get the tab contents";
 }
@@ skipping 230 matching lines @@
                      const content::NotificationSource& source) {
   content::NotificationRegistrar registrar;
   registrar.Add(observer, type, source);
   RunMessageLoop();
 }
 
 void WaitForBookmarkModelToLoad(BookmarkModel* model) {
   if (model->IsLoaded())
     return;
   base::RunLoop run_loop;
-  BookmarkLoadObserver observer(GetQuitTaskForRunLoop(&run_loop));
+  BookmarkLoadObserver observer(content::GetQuitTaskForRunLoop(&run_loop));
   model->AddObserver(&observer);
-  RunThisRunLoop(&run_loop);
+  content::RunThisRunLoop(&run_loop);
   model->RemoveObserver(&observer);
   ASSERT_TRUE(model->IsLoaded());
 }
 
 void WaitForTemplateURLServiceToLoad(TemplateURLService* service) {
   if (service->loaded())
     return;
   service->Load();
   TemplateURLServiceTestUtil::BlockTillServiceProcessesRequests();
   ASSERT_TRUE(service->loaded());
@@ skipping 103 matching lines @@
   return !testing::Test::HasFatalFailure();
 }
 
 MessageLoopRunner::MessageLoopRunner() {
 }
 
 MessageLoopRunner::~MessageLoopRunner() {
 }
 
 void MessageLoopRunner::Run() {
-  ui_test_utils::RunThisRunLoop(&run_loop_);
+  content::RunThisRunLoop(&run_loop_);
 }
 
 base::Closure MessageLoopRunner::QuitClosure() {
   return base::Bind(&MessageLoopRunner::Quit, this);
 }
 
 void MessageLoopRunner::Quit() {
-  ui_test_utils::GetQuitTaskForRunLoop(&run_loop_).Run();
+  content::GetQuitTaskForRunLoop(&run_loop_).Run();
 }
 
 TestWebSocketServer::TestWebSocketServer()
     : started_(false),
       port_(kDefaultWsPort),
       secure_(false) {
 #if defined(OS_POSIX)
   process_group_id_ = base::kNullProcessHandle;
 #endif
 }
@@ skipping 404 matching lines @@
                int state,
                const base::Closure& followup) {
   if (!followup.is_null())
     ui_controls::SendMouseEventsNotifyWhenDone(button, state, followup);
   else
     ui_controls::SendMouseEvents(button, state);
 }
 
 }  // namespace internal
 }  // namespace ui_test_utils