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

chrome/browser/ui/omnibox/omnibox_view_browsertest.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 <stdio.h>
 
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_edit.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_model.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
 #include "net/base/mock_host_resolver.h"
 #include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
@@ skipping 156 matching lines @@
   }
 
   void SendKeySequence(const wchar_t* keys) {
     for (; *keys; ++keys)
       ASSERT_NO_FATAL_FAILURE(SendKey(static_cast<ui::KeyboardCode>(*keys), 0));
   }
 
   bool SendKeyAndWait(const Browser* browser,
                       ui::KeyboardCode key,
                       int modifiers,
-                      NotificationType type,
+                      int type,
                       const NotificationSource& source) WARN_UNUSED_RESULT {
     return ui_test_utils::SendKeyPressAndWait(
         browser, key,
         (modifiers & ui::EF_CONTROL_DOWN) != 0,
         (modifiers & ui::EF_SHIFT_DOWN) != 0,
         (modifiers & ui::EF_ALT_DOWN) != 0,
         (modifiers & ui::EF_COMMAND_DOWN) != 0,
         type, source);
   }
 
   void WaitForTabOpenOrCloseForBrowser(const Browser* browser,
                                        int expected_tab_count) {
     int tab_count = browser->tab_count();
     if (tab_count == expected_tab_count)
       return;
 
     NotificationRegistrar registrar;
     registrar.Add(this,
                   (tab_count < expected_tab_count ?
-                   NotificationType::TAB_PARENTED :
-                   NotificationType::TAB_CLOSED),
+                   content::NOTIFICATION_TAB_PARENTED :
+                   content::NOTIFICATION_TAB_CLOSED),
                    NotificationService::AllSources());
 
     while (!HasFailure() && browser->tab_count() != expected_tab_count)
       ui_test_utils::RunMessageLoop();
 
     ASSERT_EQ(expected_tab_count, browser->tab_count());
   }
 
   void WaitForTabOpenOrClose(int expected_tab_count) {
     WaitForTabOpenOrCloseForBrowser(browser(), expected_tab_count);
   }
 
   void WaitForAutocompleteControllerDone() {
     OmniboxView* omnibox_view = NULL;
     ASSERT_NO_FATAL_FAILURE(GetOmniboxView(&omnibox_view));
 
     AutocompleteController* controller =
         omnibox_view->model()->popup_model()->autocomplete_controller();
     ASSERT_TRUE(controller);
 
     if (controller->done())
       return;
 
     NotificationRegistrar registrar;
     registrar.Add(this,
-                  NotificationType::AUTOCOMPLETE_CONTROLLER_RESULT_READY,
+                  chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
                   Source<AutocompleteController>(controller));
 
     while (!HasFailure() && !controller->done())
       ui_test_utils::RunMessageLoop();
 
     ASSERT_TRUE(controller->done());
   }
 
   void SetupSearchEngine() {
     TemplateURLService* model =
         TemplateURLServiceFactory::GetForProfile(browser()->profile());
     ASSERT_TRUE(model);
 
     if (!model->loaded()) {
       NotificationRegistrar registrar;
-      registrar.Add(this, NotificationType::TEMPLATE_URL_SERVICE_LOADED,
+      registrar.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED,
                     Source<TemplateURLService>(model));
       model->Load();
       ui_test_utils::RunMessageLoop();
     }
 
     ASSERT_TRUE(model->loaded());
     // Remove built-in template urls, like google.com, bing.com etc., as they
     // may appear as autocomplete suggests and interfere with our tests.
     model->SetDefaultSearchProvider(NULL);
     TemplateURLService::TemplateURLVector builtins = model->GetTemplateURLs();
@@ skipping 11 matching lines @@
   }
 
   void AddHistoryEntry(const TestHistoryEntry& entry, const Time& time) {
     Profile* profile = browser()->profile();
     HistoryService* history_service =
         profile->GetHistoryService(Profile::EXPLICIT_ACCESS);
     ASSERT_TRUE(history_service);
 
     if (!history_service->BackendLoaded()) {
       NotificationRegistrar registrar;
-      registrar.Add(this, NotificationType::HISTORY_LOADED,
+      registrar.Add(this, chrome::NOTIFICATION_HISTORY_LOADED,
                     Source<Profile>(profile));
       ui_test_utils::RunMessageLoop();
     }
 
     BookmarkModel* bookmark_model = profile->GetBookmarkModel();
     ASSERT_TRUE(bookmark_model);
 
     if (!bookmark_model->IsLoaded()) {
       NotificationRegistrar registrar;
-      registrar.Add(this, NotificationType::BOOKMARK_MODEL_LOADED,
+      registrar.Add(this, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                     Source<Profile>(profile));
       ui_test_utils::RunMessageLoop();
     }
 
     GURL url(entry.url);
     // Add everything in order of time. We don't want to have a time that
     // is "right now" or it will nondeterministically appear in the results.
     history_service->AddPageWithDetails(url, UTF8ToUTF16(entry.title),
                                         entry.visit_count,
                                         entry.typed_count, time, false,
@@ skipping 18 matching lines @@
     for (size_t i = 0; i < arraysize(kBlockedHostnames); ++i)
       host_resolver()->AddSimulatedFailure(kBlockedHostnames[i]);
   }
 
   void SetupComponents() {
     ASSERT_NO_FATAL_FAILURE(SetupHostResolver());
     ASSERT_NO_FATAL_FAILURE(SetupSearchEngine());
     ASSERT_NO_FATAL_FAILURE(SetupHistory());
   }
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-    switch (type.value) {
-      case NotificationType::TAB_PARENTED:
-      case NotificationType::TAB_CLOSED:
-      case NotificationType::TEMPLATE_URL_SERVICE_LOADED:
-      case NotificationType::AUTOCOMPLETE_CONTROLLER_RESULT_READY:
-      case NotificationType::HISTORY_LOADED:
-      case NotificationType::BOOKMARK_MODEL_LOADED:
+    switch (type) {
+      case content::NOTIFICATION_TAB_PARENTED:
+      case content::NOTIFICATION_TAB_CLOSED:
+      case chrome::NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED:
+      case chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY:
+      case chrome::NOTIFICATION_HISTORY_LOADED:
+      case chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED:
         break;
       default:
         FAIL() << "Unexpected notification type";
     }
     MessageLoopForUI::current()->Quit();
   }
 
   void BrowserAcceleratorsTest() {
     OmniboxView* omnibox_view = NULL;
     ASSERT_NO_FATAL_FAILURE(GetOmniboxView(&omnibox_view));
@@ skipping 42 matching lines @@
         SendKey(ui::VKEY_LEFT, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN));
 #endif
     EXPECT_FALSE(omnibox_view->IsSelectAll());
     ASSERT_NO_FATAL_FAILURE(SendKey(ui::VKEY_X, kCtrlOrCmdMask));
     EXPECT_EQ(ASCIIToUTF16("Hello "), omnibox_view->GetText());
 
 #if !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
     // Try alt-f4 to close the browser.
     ASSERT_TRUE(SendKeyAndWait(
         browser(), ui::VKEY_F4, ui::EF_ALT_DOWN,
-        NotificationType::BROWSER_CLOSED, Source<Browser>(browser())));
+        chrome::NOTIFICATION_BROWSER_CLOSED, Source<Browser>(browser())));
 #endif
   }
 
   void PopupAcceleratorsTest() {
     // Create a popup.
     Browser* popup = CreateBrowserForPopup(browser()->profile());
     ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(popup));
     OmniboxView* omnibox_view = NULL;
     ASSERT_NO_FATAL_FAILURE(
         GetOmniboxViewForBrowser(popup, &omnibox_view));
     popup->FocusLocationBar();
     EXPECT_TRUE(omnibox_view->IsSelectAll());
 
 #if !defined(OS_MACOSX)
     // Try ctrl-w to close the popup.
     // This piece of code doesn't work on Mac, because the Browser object won't
     // be destroyed before finishing the current message loop iteration, thus
     // No BROWSER_CLOSED notification will be sent.
     ASSERT_TRUE(SendKeyAndWait(
         popup, ui::VKEY_W, ui::EF_CONTROL_DOWN,
-        NotificationType::BROWSER_CLOSED, Source<Browser>(popup)));
+        chrome::NOTIFICATION_BROWSER_CLOSED, Source<Browser>(popup)));
 
     // Create another popup.
     popup = CreateBrowserForPopup(browser()->profile());
     ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(popup));
     ASSERT_NO_FATAL_FAILURE(
         GetOmniboxViewForBrowser(popup, &omnibox_view));
 #endif
 
     // Set the edit text to "Hello world".
     omnibox_view->SetUserText(ASCIIToUTF16("Hello world"));
     popup->FocusLocationBar();
     EXPECT_TRUE(omnibox_view->IsSelectAll());
 
     // Try editing the location bar text -- should be disallowed.
     ASSERT_NO_FATAL_FAILURE(SendKeyForBrowser(popup, ui::VKEY_S, 0));
     EXPECT_EQ(ASCIIToUTF16("Hello world"), omnibox_view->GetText());
     EXPECT_TRUE(omnibox_view->IsSelectAll());
 
     ASSERT_NO_FATAL_FAILURE(
         SendKeyForBrowser(popup, ui::VKEY_X, kCtrlOrCmdMask));
     EXPECT_EQ(ASCIIToUTF16("Hello world"), omnibox_view->GetText());
     EXPECT_TRUE(omnibox_view->IsSelectAll());
 
 #if !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
     // Try alt-f4 to close the popup.
     ASSERT_TRUE(SendKeyAndWait(
         popup, ui::VKEY_F4, ui::EF_ALT_DOWN,
-        NotificationType::BROWSER_CLOSED, Source<Browser>(popup)));
+        chrome::NOTIFICATION_BROWSER_CLOSED, Source<Browser>(popup)));
 #endif
   }
 
   void BackspaceInKeywordModeTest() {
     OmniboxView* omnibox_view = NULL;
     ASSERT_NO_FATAL_FAILURE(GetOmniboxView(&omnibox_view));
 
     // Trigger keyword hint mode.
     ASSERT_NO_FATAL_FAILURE(SendKeySequence(kSearchKeywordKeys));
     ASSERT_TRUE(omnibox_view->model()->is_keyword_hint());
@@ skipping 921 matching lines @@
                        PersistKeywordModeOnTabSwitch) {
   PersistKeywordModeOnTabSwitch();
 }
 
 IN_PROC_BROWSER_TEST_F(OmniboxViewViewsTest,
                        CtrlKeyPressedWithInlineAutocompleteTest) {
   CtrlKeyPressedWithInlineAutocompleteTest();
 }
 
 #endif