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

chrome/browser/ui/login/login_prompt_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 <algorithm>
 #include <list>
 #include <map>
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/common/notification_service.h"
 #include "net/base/auth.h"
 #include "net/base/mock_host_resolver.h"
 
 namespace {
 
@@ skipping 42 matching lines @@
 
 // Maintains a set of LoginHandlers that are currently active and
 // keeps a count of the notifications that were observed.
 class LoginPromptBrowserTestObserver : public NotificationObserver {
  public:
   LoginPromptBrowserTestObserver()
       : auth_needed_count_(0),
         auth_supplied_count_(0),
         auth_cancelled_count_(0) {}
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   void AddHandler(LoginHandler* handler);
 
   void RemoveHandler(LoginHandler* handler);
 
   void Register(const NotificationSource& source);
 
   std::list<LoginHandler*> handlers_;
 
   // The exact number of notifications we receive is depedent on the
   // number of requests that were dispatched and is subject to a
   // number of factors that we don't directly control here.  The
   // values below should only be used qualitatively.
   int auth_needed_count_;
   int auth_supplied_count_;
   int auth_cancelled_count_;
 
  private:
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginPromptBrowserTestObserver);
 };
 
 void LoginPromptBrowserTestObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  if (type == NotificationType::AUTH_NEEDED) {
+  if (type == chrome::NOTIFICATION_AUTH_NEEDED) {
     LoginNotificationDetails* login_details =
         Details<LoginNotificationDetails>(details).ptr();
     AddHandler(login_details->handler());
     auth_needed_count_++;
-  } else if (type == NotificationType::AUTH_SUPPLIED) {
+  } else if (type == chrome::NOTIFICATION_AUTH_SUPPLIED) {
     AuthSuppliedLoginNotificationDetails* login_details =
         Details<AuthSuppliedLoginNotificationDetails>(details).ptr();
     RemoveHandler(login_details->handler());
     auth_supplied_count_++;
-  } else if (type == NotificationType::AUTH_CANCELLED) {
+  } else if (type == chrome::NOTIFICATION_AUTH_CANCELLED) {
     LoginNotificationDetails* login_details =
         Details<LoginNotificationDetails>(details).ptr();
     RemoveHandler(login_details->handler());
     auth_cancelled_count_++;
   }
 }
 
 void LoginPromptBrowserTestObserver::AddHandler(LoginHandler* handler) {
   std::list<LoginHandler*>::iterator i = std::find(handlers_.begin(),
                                                    handlers_.end(),
                                                    handler);
   EXPECT_TRUE(i == handlers_.end());
   if (i == handlers_.end())
     handlers_.push_back(handler);
 }
 
 void LoginPromptBrowserTestObserver::RemoveHandler(LoginHandler* handler) {
   std::list<LoginHandler*>::iterator i = std::find(handlers_.begin(),
                                                    handlers_.end(),
                                                    handler);
   EXPECT_TRUE(i != handlers_.end());
   if (i != handlers_.end())
     handlers_.erase(i);
 }
 
 void LoginPromptBrowserTestObserver::Register(
     const NotificationSource& source) {
-  registrar_.Add(this, NotificationType::AUTH_NEEDED, source);
-  registrar_.Add(this, NotificationType::AUTH_SUPPLIED, source);
-  registrar_.Add(this, NotificationType::AUTH_CANCELLED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_NEEDED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_SUPPLIED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_CANCELLED, source);
 }
 
-template <NotificationType::Type T>
+template <int T>
 class WindowedNavigationObserver
     : public ui_test_utils::WindowedNotificationObserver {
  public:
   explicit WindowedNavigationObserver(NavigationController* controller)
       : ui_test_utils::WindowedNotificationObserver(
           T, Source<NavigationController>(controller)) {}
 };
 
-typedef WindowedNavigationObserver<NotificationType::LOAD_STOP>
+typedef WindowedNavigationObserver<content::NOTIFICATION_LOAD_STOP>
     WindowedLoadStopObserver;
 
-typedef WindowedNavigationObserver<NotificationType::AUTH_NEEDED>
+typedef WindowedNavigationObserver<chrome::NOTIFICATION_AUTH_NEEDED>
     WindowedAuthNeededObserver;
 
-typedef WindowedNavigationObserver<NotificationType::AUTH_CANCELLED>
+typedef WindowedNavigationObserver<chrome::NOTIFICATION_AUTH_CANCELLED>
     WindowedAuthCancelledObserver;
 
-typedef WindowedNavigationObserver<NotificationType::AUTH_SUPPLIED>
+typedef WindowedNavigationObserver<chrome::NOTIFICATION_AUTH_SUPPLIED>
     WindowedAuthSuppliedObserver;
 
 const char* kPrefetchAuthPage = "files/login/prefetch.html";
 
 const char* kMultiRealmTestPage = "files/login/multi_realm.html";
 const int   kMultiRealmTestRealmCount = 2;
 const int   kMultiRealmTestResourceCount = 4;
 
 const char* kSingleRealmTestPage = "files/login/single_realm.html";
 const int   kSingleRealmTestResourceCount = 6;
@@ skipping 358 matching lines @@
       handler->CancelAuth();
       auth_cancelled_waiter.Wait();
     }
   }
 
   EXPECT_EQ(1, observer.auth_needed_count_);
   EXPECT_TRUE(test_server()->Stop());
 }
 
 }  // namespace