Create content\public\test\test_utils.h to hold common test classes that are used by unit and brows…

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 47 matching lines @@
 #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 "content/public/test/test_utils.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(USE_AURA)
@@ skipping 19 matching lines @@
 
 class DOMOperationObserver : public content::NotificationObserver,
                              public content::WebContentsObserver {
  public:
   explicit DOMOperationObserver(RenderViewHost* render_view_host)
       : content::WebContentsObserver(
             WebContents::FromRenderViewHost(render_view_host)),
         did_respond_(false) {
     registrar_.Add(this, content::NOTIFICATION_DOM_OPERATION_RESPONSE,
                    content::Source<RenderViewHost>(render_view_host));
-    message_loop_runner_ = new MessageLoopRunner;
+    message_loop_runner_ = new content::MessageLoopRunner;
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     DCHECK(type == content::NOTIFICATION_DOM_OPERATION_RESPONSE);
     content::Details<DomOperationNotificationDetails> dom_op_details(details);
     response_ = dom_op_details->json;
     did_respond_ = true;
     message_loop_runner_->Quit();
   }
 
   // Overridden from content::WebContentsObserver:
   virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE {
     message_loop_runner_->Quit();
   }
 
   bool WaitAndGetResponse(std::string* response) WARN_UNUSED_RESULT {
     message_loop_runner_->Run();
     *response = response_;
     return did_respond_;
   }
 
  private:
   content::NotificationRegistrar registrar_;
   std::string response_;
   bool did_respond_;
-  scoped_refptr<MessageLoopRunner> message_loop_runner_;
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(DOMOperationObserver);
 };
 
 class FindInPageNotificationObserver : public content::NotificationObserver {
  public:
   explicit FindInPageNotificationObserver(TabContents* parent_tab)
       : parent_tab_(parent_tab),
         active_match_ordinal_(-1),
         number_of_matches_(0) {
     current_find_request_id_ =
         parent_tab->find_tab_helper()->current_find_request_id();
     registrar_.Add(this, chrome::NOTIFICATION_FIND_RESULT_AVAILABLE,
                    content::Source<WebContents>(parent_tab_->web_contents()));
-    message_loop_runner_ = new MessageLoopRunner;
+    message_loop_runner_ = new content::MessageLoopRunner;
     message_loop_runner_->Run();
   }
 
   int active_match_ordinal() const { return active_match_ordinal_; }
 
   int number_of_matches() const { return number_of_matches_; }
 
   virtual void Observe(int type, const content::NotificationSource& source,
                        const content::NotificationDetails& details) {
     if (type == chrome::NOTIFICATION_FIND_RESULT_AVAILABLE) {
@@ skipping 18 matching lines @@
  private:
   content::NotificationRegistrar registrar_;
   TabContents* parent_tab_;
   // We will at some point (before final update) be notified of the ordinal and
   // we need to preserve it so we can send it later.
   int active_match_ordinal_;
   int number_of_matches_;
   // The id of the current find request, obtained from WebContents. Allows us
   // to monitor when the search completes.
   int current_find_request_id_;
-  scoped_refptr<MessageLoopRunner> message_loop_runner_;
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(FindInPageNotificationObserver);
 };
 
 class InProcessJavaScriptExecutionController
     : public base::RefCounted<InProcessJavaScriptExecutionController>,
       public JavaScriptExecutionController {
  public:
   explicit InProcessJavaScriptExecutionController(
       RenderViewHost* render_view_host)
@@ skipping 120 matching lines @@
   content::TestNavigationObserver observer(
       content::Source<NavigationController>(controller), NULL,
       number_of_navigations);
   base::RunLoop run_loop;
   observer.WaitForObservation(
       base::Bind(&content::RunThisRunLoop, base::Unretained(&run_loop)),
       content::GetQuitTaskForRunLoop(&run_loop));
 }
 
 void WaitForNewTab(Browser* browser) {
-  WindowedNotificationObserver observer(
+  content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_TAB_ADDED,
       content::Source<content::WebContentsDelegate>(browser));
   observer.Wait();
 }
 
 void WaitForLoadStop(WebContents* tab) {
-  WindowedNotificationObserver load_stop_observer(
+  content::WindowedNotificationObserver load_stop_observer(
       content::NOTIFICATION_LOAD_STOP,
       content::Source<NavigationController>(&tab->GetController()));
   // In many cases, the load may have finished before we get here.  Only wait if
   // the tab still has a pending navigation.
   if (!tab->IsLoading())
     return;
   load_stop_observer.Wait();
 }
 
 Browser* WaitForBrowserNotInSet(std::set<Browser*> excluded_browsers) {
@@ skipping 51 matching lines @@
       NULL,
       number_of_navigations);
 
   std::set<Browser*> initial_browsers;
   for (std::vector<Browser*>::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end();
        ++iter) {
     initial_browsers.insert(*iter);
   }
 
-  WindowedNotificationObserver tab_added_observer(
+  content::WindowedNotificationObserver tab_added_observer(
       chrome::NOTIFICATION_TAB_ADDED,
       content::NotificationService::AllSources());
 
-  WindowedNotificationObserver auth_observer(
+  content::WindowedNotificationObserver auth_observer(
       chrome::NOTIFICATION_AUTH_NEEDED,
       content::NotificationService::AllSources());
 
   browser->OpenURL(OpenURLParams(
       url, Referrer(), disposition, content::PAGE_TRANSITION_TYPED, false));
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_BROWSER)
     browser = WaitForBrowserNotInSet(initial_browsers);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_TAB)
     tab_added_observer.Wait();
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_AUTH)
@@ skipping 127 matching lines @@
   GURL url = net::FilePathToFileURL(path);
   if (!query_string.empty()) {
     GURL::Replacements replacements;
     replacements.SetQueryStr(query_string);
     return url.ReplaceComponents(replacements);
   }
   return url;
 }
 
 AppModalDialog* WaitForAppModalDialog() {
-  WindowedNotificationObserver observer(
+  content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
       content::NotificationService::AllSources());
   observer.Wait();
   return content::Source<AppModalDialog>(observer.source()).ptr();
 }
 
 void WaitForAppModalDialogAndCloseIt() {
   AppModalDialog* dialog = WaitForAppModalDialog();
   dialog->CloseModalDialog();
 }
 
 void CrashTab(WebContents* tab) {
   content::RenderProcessHost* rph = tab->GetRenderProcessHost();
-  WindowedNotificationObserver observer(
+  content::WindowedNotificationObserver observer(
       content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::Source<content::RenderProcessHost>(rph));
   base::KillProcess(rph->GetHandle(), 0, false);
   observer.Wait();
 }
 
 int FindInPage(TabContents* tab_contents, const string16& search_string,
                bool forward, bool match_case, int* ordinal) {
   tab_contents->
       find_tab_helper()->StartFinding(search_string, forward, match_case);
@@ skipping 119 matching lines @@
 
 void WaitForTemplateURLServiceToLoad(TemplateURLService* service) {
   if (service->loaded())
     return;
   service->Load();
   TemplateURLServiceTestUtil::BlockTillServiceProcessesRequests();
   ASSERT_TRUE(service->loaded());
 }
 
 void WaitForHistoryToLoad(HistoryService* history_service) {
-  WindowedNotificationObserver history_loaded_observer(
+  content::WindowedNotificationObserver history_loaded_observer(
       chrome::NOTIFICATION_HISTORY_LOADED,
       content::NotificationService::AllSources());
   if (!history_service->BackendLoaded())
     history_loaded_observer.Wait();
 }
 
 bool GetNativeWindow(const Browser* browser, gfx::NativeWindow* native_window) {
   BrowserWindow* window = browser->window();
   if (!window)
     return false;
@@ skipping 23 matching lines @@
 
 bool SendKeyPressSync(const Browser* browser,
                       ui::KeyboardCode key,
                       bool control,
                       bool shift,
                       bool alt,
                       bool command) {
   gfx::NativeWindow window = NULL;
   if (!GetNativeWindow(browser, &window))
     return false;
-  scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
+  scoped_refptr<content::MessageLoopRunner> runner =
+      new content::MessageLoopRunner;
   bool result;
   result = ui_controls::SendKeyPressNotifyWhenDone(
       window, key, control, shift, alt, command, runner->QuitClosure());
 #if defined(OS_WIN)
   if (!result && BringBrowserWindowToFront(browser)) {
     result = ui_controls::SendKeyPressNotifyWhenDone(
         window, key, control, shift, alt, command, runner->QuitClosure());
   }
 #endif
   if (!result) {
     LOG(ERROR) << "ui_controls::SendKeyPressNotifyWhenDone failed";
     return false;
   }
 
   // Run the message loop. It'll stop running when either the key was received
   // or the test timed out (in which case testing::Test::HasFatalFailure should
   // be set).
   runner->Run();
   return !testing::Test::HasFatalFailure();
 }
 
 bool SendKeyPressAndWait(const Browser* browser,
                          ui::KeyboardCode key,
                          bool control,
                          bool shift,
                          bool alt,
                          bool command,
                          int type,
                          const content::NotificationSource& source) {
-  WindowedNotificationObserver observer(type, source);
+  content::WindowedNotificationObserver observer(type, source);
 
   if (!SendKeyPressSync(browser, key, control, shift, alt, command))
     return false;
 
   observer.Wait();
   return !testing::Test::HasFatalFailure();
 }
 
 bool SendMouseMoveSync(const gfx::Point& location) {
-  scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
+  scoped_refptr<content::MessageLoopRunner> runner =
+      new content::MessageLoopRunner;
   if (!ui_controls::SendMouseMoveNotifyWhenDone(
           location.x(), location.y(), runner->QuitClosure())) {
     return false;
   }
   runner->Run();
   return !testing::Test::HasFatalFailure();
 }
 
 bool SendMouseEventsSync(ui_controls::MouseButton type, int state) {
-  scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
+  scoped_refptr<content::MessageLoopRunner> runner =
+      new content::MessageLoopRunner;
   if (!ui_controls::SendMouseEventsNotifyWhenDone(
           type, state, runner->QuitClosure())) {
     return false;
   }
   runner->Run();
   return !testing::Test::HasFatalFailure();
 }
 
-MessageLoopRunner::MessageLoopRunner() {
-}
-
-MessageLoopRunner::~MessageLoopRunner() {
-}
-
-void MessageLoopRunner::Run() {
-  content::RunThisRunLoop(&run_loop_);
-}
-
-base::Closure MessageLoopRunner::QuitClosure() {
-  return base::Bind(&MessageLoopRunner::Quit, this);
-}
-
-void MessageLoopRunner::Quit() {
-  content::GetQuitTaskForRunLoop(&run_loop_).Run();
-}
-
 TestWebSocketServer::TestWebSocketServer()
     : started_(false),
       port_(kDefaultWsPort),
       secure_(false) {
 #if defined(OS_POSIX)
   process_group_id_ = base::kNullProcessHandle;
 #endif
 }
 
 int TestWebSocketServer::UseRandomPort() {
@@ skipping 126 matching lines @@
   options.wait = true;
   base::LaunchProcess(*cmd_line.get(), options, NULL);
 
 #if defined(OS_POSIX)
   // Just to make sure that the server process terminates certainly.
   if (process_group_id_ != base::kNullProcessHandle)
     base::KillProcessGroup(process_group_id_);
 #endif
 }
 
-WindowedNotificationObserver::WindowedNotificationObserver(
-    int notification_type,
-    const content::NotificationSource& source)
-    : seen_(false),
-      running_(false),
-      source_(content::NotificationService::AllSources()) {
-  registrar_.Add(this, notification_type, source);
-}
-
-WindowedNotificationObserver::~WindowedNotificationObserver() {}
-
-void WindowedNotificationObserver::Wait() {
-  if (seen_)
-    return;
-
-  running_ = true;
-  message_loop_runner_ = new MessageLoopRunner;
-  message_loop_runner_->Run();
-  EXPECT_TRUE(seen_);
-}
-
-void WindowedNotificationObserver::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  source_ = source;
-  details_ = details;
-  seen_ = true;
-  if (!running_)
-    return;
-
-  message_loop_runner_->Quit();
-  running_ = false;
-}
-
 WindowedTabAddedNotificationObserver::WindowedTabAddedNotificationObserver(
     const content::NotificationSource& source)
     : WindowedNotificationObserver(chrome::NOTIFICATION_TAB_ADDED, source),
       added_tab_(NULL) {
 }
 
 void WindowedTabAddedNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  added_tab_ = content::Details<content::WebContents>(details).ptr();
-  WindowedNotificationObserver::Observe(type, source, details);
+  added_tab_ = content::Details<WebContents>(details).ptr();
+  content::WindowedNotificationObserver::Observe(type, source, details);
 }
 
 TitleWatcher::TitleWatcher(WebContents* web_contents,
                            const string16& expected_title)
     : web_contents_(web_contents),
       expected_title_observed_(false),
       quit_loop_on_observation_(false) {
   EXPECT_TRUE(web_contents != NULL);
   expected_titles_.push_back(expected_title);
   notification_registrar_.Add(this,
@@ skipping 15 matching lines @@
   expected_titles_.push_back(expected_title);
 }
 
 TitleWatcher::~TitleWatcher() {
 }
 
 const string16& TitleWatcher::WaitAndGetTitle() {
   if (expected_title_observed_)
     return observed_title_;
   quit_loop_on_observation_ = true;
-  message_loop_runner_ = new MessageLoopRunner;
+  message_loop_runner_ = new content::MessageLoopRunner;
   message_loop_runner_->Run();
   return observed_title_;
 }
 
 void TitleWatcher::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED) {
     WebContents* source_contents = content::Source<WebContents>(source).ptr();
     ASSERT_EQ(web_contents_, source_contents);
@@ skipping 57 matching lines @@
 }
 
 void DOMMessageQueue::ClearQueue() {
   message_queue_ = std::queue<std::string>();
 }
 
 bool DOMMessageQueue::WaitForMessage(std::string* message) {
   if (message_queue_.empty()) {
     waiting_for_message_ = true;
     // This will be quit when a new message comes in.
-    message_loop_runner_ = new MessageLoopRunner;
+    message_loop_runner_ = new content::MessageLoopRunner;
     message_loop_runner_->Run();
   }
   // The queue should not be empty, unless we were quit because of a timeout.
   if (message_queue_.empty())
     return false;
   if (message)
     *message = message_queue_.front();
   return true;
 }
 
 // Coordinates taking snapshots of a |RenderWidget|.
 class SnapshotTaker {
  public:
   SnapshotTaker() : bitmap_(NULL) {}
 
   bool TakeRenderWidgetSnapshot(RenderWidgetHost* rwh,
                                 const gfx::Size& page_size,
                                 const gfx::Size& desired_size,
                                 SkBitmap* bitmap) WARN_UNUSED_RESULT {
     bitmap_ = bitmap;
     ThumbnailGenerator* generator = g_browser_process->GetThumbnailGenerator();
     generator->MonitorRenderer(rwh, true);
     snapshot_taken_ = false;
     generator->AskForSnapshot(
         rwh,
         base::Bind(&SnapshotTaker::OnSnapshotTaken, base::Unretained(this)),
         page_size,
         desired_size);
-    message_loop_runner_ = new MessageLoopRunner;
+    message_loop_runner_ = new content::MessageLoopRunner;
     message_loop_runner_->Run();
     return snapshot_taken_;
   }
 
   bool TakeEntirePageSnapshot(RenderViewHost* rvh,
                               SkBitmap* bitmap) WARN_UNUSED_RESULT {
     const wchar_t* script =
         L"window.domAutomationController.send("
         L"    JSON.stringify([document.width, document.height]))";
     std::string json;
@@ skipping 22 matching lines @@
   void OnSnapshotTaken(const SkBitmap& bitmap) {
     *bitmap_ = bitmap;
     snapshot_taken_ = true;
     message_loop_runner_->Quit();
   }
 
   SkBitmap* bitmap_;
   // Whether the snapshot was actually taken and received by this SnapshotTaker.
   // This will be false if the test times out.
   bool snapshot_taken_;
-  scoped_refptr<MessageLoopRunner> message_loop_runner_;
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotTaker);
 };
 
 bool TakeRenderWidgetSnapshot(RenderWidgetHost* rwh,
                               const gfx::Size& page_size,
                               SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeRenderWidgetSnapshot(rwh, page_size, page_size, bitmap);
 }
 
 bool TakeEntirePageSnapshot(RenderViewHost* rvh, SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeEntirePageSnapshot(rvh, bitmap);
 }
 
 void OverrideGeolocation(double latitude, double longitude) {
   content::Geoposition position;
   position.latitude = latitude;
   position.longitude = longitude;
   position.altitude = 0.;
   position.accuracy = 0.;
   position.timestamp = base::Time::Now();
-  scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
+  scoped_refptr<content::MessageLoopRunner> runner =
+      new content::MessageLoopRunner;
   content::OverrideLocationForTesting(position, runner->QuitClosure());
   runner->Run();
 }
 
 namespace internal {
 
 void ClickTask(ui_controls::MouseButton button,
                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