Moving notification types which are chrome specific to a new header file chrome_notification_type...

chrome/test/ui_test_utils.cc

 // Copyright (c) 2011 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/ui_test_utils.h"
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/thumbnail_generator.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/find_bar/find_notification_details.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/test/automation/javascript_execution_controller.h"
 #include "chrome/test/bookmark_load_observer.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
-#include "content/common/notification_type.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.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"
 
 #if defined(TOOLKIT_VIEWS)
 #include "views/focus/accelerator_handler.h"
 #endif
 
 namespace ui_test_utils {
 
 namespace {
 
 // Used to block until a navigation completes.
 class NavigationNotificationObserver : public NotificationObserver {
  public:
   NavigationNotificationObserver(NavigationController* controller,
                                  int number_of_navigations)
       : navigation_started_(false),
         navigations_completed_(0),
         number_of_navigations_(number_of_navigations),
         running_(false),
         done_(false) {
-    registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+    registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    Source<NavigationController>(controller));
-    registrar_.Add(this, NotificationType::LOAD_START,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                    Source<NavigationController>(controller));
-    registrar_.Add(this, NotificationType::LOAD_STOP,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    Source<NavigationController>(controller));
   }
 
   void Run() {
     if (!done_) {
       running_ = true;
       RunMessageLoop();
     }
   }
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-    if (type == NotificationType::NAV_ENTRY_COMMITTED ||
-        type == NotificationType::LOAD_START) {
+    if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED ||
+        type == content::NOTIFICATION_LOAD_START) {
       navigation_started_ = true;
-    } else if (type == NotificationType::LOAD_STOP) {
+    } else if (type == content::NOTIFICATION_LOAD_STOP) {
       if (navigation_started_ &&
           ++navigations_completed_ == number_of_navigations_) {
         navigation_started_ = false;
         done_ = true;
         if (running_)
           MessageLoopForUI::current()->Quit();
       }
     }
   }
 
@@ skipping 16 matching lines @@
   // done if we never had to start an event loop.
   bool running_;
   bool done_;
   DISALLOW_COPY_AND_ASSIGN(NavigationNotificationObserver);
 };
 
 class DOMOperationObserver : public NotificationObserver {
  public:
   explicit DOMOperationObserver(RenderViewHost* render_view_host)
       : did_respond_(false) {
-    registrar_.Add(this, NotificationType::DOM_OPERATION_RESPONSE,
+    registrar_.Add(this, chrome::NOTIFICATION_DOM_OPERATION_RESPONSE,
                    Source<RenderViewHost>(render_view_host));
     ui_test_utils::RunMessageLoop();
   }
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-    DCHECK(type == NotificationType::DOM_OPERATION_RESPONSE);
+    DCHECK(type == chrome::NOTIFICATION_DOM_OPERATION_RESPONSE);
     Details<DomOperationNotificationDetails> dom_op_details(details);
     response_ = dom_op_details->json();
     did_respond_ = true;
     MessageLoopForUI::current()->Quit();
   }
 
   bool GetResponse(std::string* response) WARN_UNUSED_RESULT {
     *response = response_;
     return did_respond_;
   }
 
  private:
   NotificationRegistrar registrar_;
   std::string response_;
   bool did_respond_;
 
   DISALLOW_COPY_AND_ASSIGN(DOMOperationObserver);
 };
 
 class FindInPageNotificationObserver : public NotificationObserver {
  public:
   explicit FindInPageNotificationObserver(TabContentsWrapper* 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, NotificationType::FIND_RESULT_AVAILABLE,
+    registrar_.Add(this, chrome::NOTIFICATION_FIND_RESULT_AVAILABLE,
                    Source<TabContents>(parent_tab_->tab_contents()));
     ui_test_utils::RunMessageLoop();
   }
 
   int active_match_ordinal() const { return active_match_ordinal_; }
 
   int number_of_matches() const { return number_of_matches_; }
 
-  virtual void Observe(NotificationType type, const NotificationSource& source,
+  virtual void Observe(int type, const NotificationSource& source,
                        const NotificationDetails& details) {
-    if (type == NotificationType::FIND_RESULT_AVAILABLE) {
+    if (type == chrome::NOTIFICATION_FIND_RESULT_AVAILABLE) {
       Details<FindNotificationDetails> find_details(details);
       if (find_details->request_id() == current_find_request_id_) {
         // We get multiple responses and one of those will contain the ordinal.
         // This message comes to us before the final update is sent.
         if (find_details->active_match_ordinal() > -1)
           active_match_ordinal_ = find_details->active_match_ordinal();
         if (find_details->final_update()) {
           number_of_matches_ = find_details->number_of_matches();
           MessageLoopForUI::current()->Quit();
         } else {
@@ skipping 152 matching lines @@
 }
 
 void WaitForNavigations(NavigationController* controller,
                         int number_of_navigations) {
   NavigationNotificationObserver observer(controller, number_of_navigations);
   observer.Run();
 }
 
 void WaitForNewTab(Browser* browser) {
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::TAB_ADDED,
+  RegisterAndWait(&observer, content::NOTIFICATION_TAB_ADDED,
                   Source<Browser>(browser));
 }
 
 void WaitForBrowserActionUpdated(ExtensionAction* browser_action) {
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
+  RegisterAndWait(&observer,
+                  chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
                   Source<ExtensionAction>(browser_action));
 }
 
 void WaitForLoadStop(TabContents* tab) {
   // In many cases, the load may have finished before we get here.  Only wait if
   // the tab still has a pending navigation.
   if (!tab->is_loading() && !tab->render_manager()->pending_render_view_host())
     return;
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::LOAD_STOP,
+  RegisterAndWait(&observer, content::NOTIFICATION_LOAD_STOP,
                   Source<NavigationController>(&tab->controller()));
 }
 
 Browser* WaitForNewBrowser() {
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::BROWSER_WINDOW_READY,
+  RegisterAndWait(&observer, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                   NotificationService::AllSources());
   return Source<Browser>(observer.source()).ptr();
 }
 
 Browser* WaitForBrowserNotInSet(std::set<Browser*> excluded_browsers) {
   TestNotificationObserver observer;
   Browser* new_browser = GetBrowserNotInSet(excluded_browsers);
   if (new_browser == NULL) {
     new_browser = WaitForNewBrowser();
     // The new browser should never be in |excluded_browsers|.
@@ skipping 31 matching lines @@
   std::set<Browser*> initial_browsers;
   for (std::vector<Browser*>::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end();
        ++iter) {
     initial_browsers.insert(*iter);
   }
   browser->OpenURL(url, GURL(), disposition, PageTransition::TYPED);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_BROWSER)
     browser = WaitForBrowserNotInSet(initial_browsers);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_TAB)
-    WaitForNotification(NotificationType::TAB_ADDED);
+    WaitForNotification(content::NOTIFICATION_TAB_ADDED);
   if (!(browser_test_flags & BROWSER_TEST_WAIT_FOR_NAVIGATION)) {
     // Some other flag caused the wait prior to this.
     return;
   }
   TabContents* tab_contents = NULL;
   if (disposition == NEW_BACKGROUND_TAB) {
     // We've opened up a new tab, but not selected it.
     tab_contents = browser->GetTabContentsAt(browser->active_index() + 1);
     EXPECT_TRUE(tab_contents != NULL)
         << " Unable to wait for navigation to \"" << url.spec()
@@ skipping 113 matching lines @@
   if (!query_string.empty()) {
     GURL::Replacements replacements;
     replacements.SetQueryStr(query_string);
     return url.ReplaceComponents(replacements);
   }
   return url;
 }
 
 AppModalDialog* WaitForAppModalDialog() {
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::APP_MODAL_DIALOG_SHOWN,
+  RegisterAndWait(&observer, chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
                   NotificationService::AllSources());
   return Source<AppModalDialog>(observer.source()).ptr();
 }
 
 void CrashTab(TabContents* tab) {
   RenderProcessHost* rph = tab->render_view_host()->process();
   base::KillProcess(rph->GetHandle(), 0, false);
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::RENDERER_PROCESS_CLOSED,
+  RegisterAndWait(&observer, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                   Source<RenderProcessHost>(rph));
 }
 
 void WaitForFocusChange(TabContents* tab_contents) {
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::FOCUS_CHANGED_IN_PAGE,
+  RegisterAndWait(&observer, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
                   Source<TabContents>(tab_contents));
 }
 
 void WaitForFocusInBrowser(Browser* browser) {
   TestNotificationObserver observer;
-  RegisterAndWait(&observer, NotificationType::FOCUS_RETURNED_TO_BROWSER,
+  RegisterAndWait(&observer, chrome::NOTIFICATION_FOCUS_RETURNED_TO_BROWSER,
                   Source<Browser>(browser));
 }
 
 int FindInPage(TabContentsWrapper* tab_contents, const string16& search_string,
                bool forward, bool match_case, int* ordinal) {
   tab_contents->
       find_tab_helper()->StartFinding(search_string, forward, match_case);
   FindInPageNotificationObserver observer(tab_contents);
   if (ordinal)
     *ordinal = observer.active_match_ordinal();
   return observer.number_of_matches();
 }
 
-void WaitForNotification(NotificationType type) {
+void WaitForNotification(int type) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, type, NotificationService::AllSources());
 }
 
-void WaitForNotificationFrom(NotificationType type,
+void WaitForNotificationFrom(int type,
                              const NotificationSource& source) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, type, source);
 }
 
 void RegisterAndWait(NotificationObserver* observer,
-                     NotificationType type,
+                     int type,
                      const NotificationSource& source) {
   NotificationRegistrar registrar;
   registrar.Add(observer, type, source);
   RunMessageLoop();
 }
 
 void WaitForBookmarkModelToLoad(BookmarkModel* model) {
   if (model->IsLoaded())
     return;
   BookmarkLoadObserver observer;
   model->AddObserver(&observer);
   RunMessageLoop();
   model->RemoveObserver(&observer);
   ASSERT_TRUE(model->IsLoaded());
 }
 
 void WaitForHistoryToLoad(Browser* browser) {
   HistoryService* history_service =
       browser->profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (!history_service->BackendLoaded())
-    WaitForNotification(NotificationType::HISTORY_LOADED);
+    WaitForNotification(chrome::NOTIFICATION_HISTORY_LOADED);
 }
 
 bool GetNativeWindow(const Browser* browser, gfx::NativeWindow* native_window) {
   BrowserWindow* window = browser->window();
   if (!window)
     return false;
 
   *native_window = window->GetNativeHandle();
   return *native_window;
 }
@@ skipping 40 matching lines @@
   RunMessageLoop();
   return !testing::Test::HasFatalFailure();
 }
 
 bool SendKeyPressAndWait(const Browser* browser,
                          ui::KeyboardCode key,
                          bool control,
                          bool shift,
                          bool alt,
                          bool command,
-                         NotificationType type,
+                         int type,
                          const NotificationSource& source) {
   WindowedNotificationObserver observer(type, source);
 
   if (!SendKeyPressSync(browser, key, control, shift, alt, command))
     return false;
 
   observer.Wait();
   return !testing::Test::HasFatalFailure();
 }
 
@@ skipping 131 matching lines @@
                             websocket_pid_file_.value());
   base::LaunchApp(*cmd_line.get(), true, false, NULL);
 }
 
 TestNotificationObserver::TestNotificationObserver()
     : source_(NotificationService::AllSources()) {
 }
 
 TestNotificationObserver::~TestNotificationObserver() {}
 
-void TestNotificationObserver::Observe(NotificationType type,
+void TestNotificationObserver::Observe(int type,
                                        const NotificationSource& source,
                                        const NotificationDetails& details) {
   source_ = source;
   details_ = details;
   MessageLoopForUI::current()->Quit();
 }
 
 WindowedNotificationObserver::WindowedNotificationObserver(
-    NotificationType notification_type,
+    int notification_type,
     const NotificationSource& source)
     : seen_(false),
       running_(false),
       waiting_for_(source) {
   registrar_.Add(this, notification_type, waiting_for_);
 }
 
 WindowedNotificationObserver::~WindowedNotificationObserver() {}
 
 void WindowedNotificationObserver::Wait() {
@@ skipping 13 matching lines @@
   }
 
   waiting_for_ = source;
   if (sources_seen_.count(waiting_for_.map_key()) > 0)
     return;
 
   running_ = true;
   ui_test_utils::RunMessageLoop();
 }
 
-void WindowedNotificationObserver::Observe(NotificationType type,
+void WindowedNotificationObserver::Observe(int type,
                                            const NotificationSource& source,
                                            const NotificationDetails& details) {
   if (waiting_for_ == source ||
       (running_ && waiting_for_ == NotificationService::AllSources())) {
     seen_ = true;
     if (running_)
       MessageLoopForUI::current()->Quit();
   } else {
     sources_seen_.insert(source.map_key());
   }
 }
 
 TitleWatcher::TitleWatcher(TabContents* tab_contents,
                            const string16& expected_title)
     : expected_tab_(tab_contents),
       expected_title_(expected_title),
       title_observed_(false),
       quit_loop_on_observation_(false) {
   EXPECT_TRUE(tab_contents != NULL);
   notification_registrar_.Add(this,
-                              NotificationType::TAB_CONTENTS_TITLE_UPDATED,
+                              content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED,
                               Source<TabContents>(tab_contents));
 }
 
 TitleWatcher::~TitleWatcher() {
 }
 
 bool TitleWatcher::Wait() {
   if (title_observed_)
     return true;
   quit_loop_on_observation_ = true;
   ui_test_utils::RunMessageLoop();
   return title_observed_;
 }
 
-void TitleWatcher::Observe(NotificationType type,
+void TitleWatcher::Observe(int type,
                            const NotificationSource& source,
                            const NotificationDetails& details) {
-  if (type != NotificationType::TAB_CONTENTS_TITLE_UPDATED)
+  if (type != content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED)
     return;
 
   TabContents* source_contents = Source<TabContents>(source).ptr();
   ASSERT_EQ(expected_tab_, source_contents);
   if (source_contents->GetTitle() != expected_title_)
     return;
 
   title_observed_ = true;
   if (quit_loop_on_observation_)
     MessageLoopForUI::current()->Quit();
 }
 
 DOMMessageQueue::DOMMessageQueue() {
-  registrar_.Add(this, NotificationType::DOM_OPERATION_RESPONSE,
+  registrar_.Add(this, chrome::NOTIFICATION_DOM_OPERATION_RESPONSE,
                  NotificationService::AllSources());
 }
 
 DOMMessageQueue::~DOMMessageQueue() {}
 
-void DOMMessageQueue::Observe(NotificationType type,
+void DOMMessageQueue::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   Details<DomOperationNotificationDetails> dom_op_details(details);
   Source<RenderViewHost> sender(source);
   message_queue_.push(dom_op_details->json());
   if (waiting_for_message_) {
     waiting_for_message_ = false;
     MessageLoopForUI::current()->Quit();
   }
 }
@@ skipping 84 matching lines @@
   return taker.TakeRenderWidgetSnapshot(rwh, page_size, page_size, bitmap);
 }
 
 bool TakeEntirePageSnapshot(RenderViewHost* rvh, SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeEntirePageSnapshot(rvh, bitmap);
 }
 
 }  // namespace ui_test_utils