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

chrome/browser/sync/signin_manager.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/browser/sync/signin_manager.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/common/notification_service.h"
 
 const char kGetInfoEmailKey[] = "email";
 
 SigninManager::SigninManager()
     : profile_(NULL), had_two_factor_error_(false) {}
 
@@ skipping 12 matching lines @@
   profile_->GetTokenService()->Initialize(
       GaiaConstants::kChromeSource, profile_);
   if (!username_.empty()) {
     profile_->GetTokenService()->LoadTokensFromDB();
   }
 }
 
 void SigninManager::CleanupNotificationRegistration() {
 #if !defined(OS_CHROMEOS)
   if (registrar_.IsRegistered(this,
-                              NotificationType::TOKEN_AVAILABLE,
+                              chrome::NOTIFICATION_TOKEN_AVAILABLE,
                               NotificationService::AllSources())) {
     registrar_.Remove(this,
-                      NotificationType::TOKEN_AVAILABLE,
+                      chrome::NOTIFICATION_TOKEN_AVAILABLE,
                       NotificationService::AllSources());
   }
 #endif
 }
 
 // If a username already exists, the user is logged in.
 const std::string& SigninManager::GetUsername() {
   return username_;
 }
 
@@ skipping 26 matching lines @@
                                   login_captcha,
                                   GaiaAuthFetcher::HostedAccountsNotAllowed);
 
   // Register for token availability.  The signin manager will pre-login the
   // user when the GAIA service token is ready for use.  Only do this if we
   // are not running in ChomiumOS, since it handles pre-login itself.
 #if !defined(OS_CHROMEOS)
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableAutoLogin)) {
     registrar_.Add(this,
-                   NotificationType::TOKEN_AVAILABLE,
+                   chrome::NOTIFICATION_TOKEN_AVAILABLE,
                    NotificationService::AllSources());
   }
 #endif
 }
 
 void SigninManager::ProvideSecondFactorAccessCode(
     const std::string& access_code) {
   DCHECK(!username_.empty() && !password_.empty() &&
       last_result_.data.empty());
 
@@ skipping 34 matching lines @@
 void SigninManager::OnGetUserInfoSuccess(const std::string& key,
                                          const std::string& value) {
   DCHECK(key == kGetInfoEmailKey);
 
   username_ = value;
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, username_);
   profile_->GetPrefs()->ScheduleSavePersistentPrefs();
 
   GoogleServiceSigninSuccessDetails details(username_, password_);
   NotificationService::current()->Notify(
-      NotificationType::GOOGLE_SIGNIN_SUCCESSFUL,
+      chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
       Source<Profile>(profile_),
       Details<const GoogleServiceSigninSuccessDetails>(&details));
 
   password_.clear();  // Don't need it anymore.
 
   profile_->GetTokenService()->UpdateCredentials(last_result_);
   DCHECK(profile_->GetTokenService()->AreCredentialsValid());
   profile_->GetTokenService()->StartFetchingTokens();
 }
 
@@ skipping 12 matching lines @@
 
 void SigninManager::OnTokenAuthFailure(const GoogleServiceAuthError& error) {
 #if !defined(OS_CHROMEOS)
   LOG(INFO) << "Unable to retreive the token auth.";
   CleanupNotificationRegistration();
 #endif
 }
 
 void SigninManager::OnClientLoginFailure(const GoogleServiceAuthError& error) {
   NotificationService::current()->Notify(
-      NotificationType::GOOGLE_SIGNIN_FAILED,
+      chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED,
       Source<Profile>(profile_),
       Details<const GoogleServiceAuthError>(&error));
 
   // We don't sign-out if the password was valid and we're just dealing with
   // a second factor error, and we don't sign out if we're dealing with
   // an invalid access code (again, because the password was valid).
   bool invalid_gaia = error.state() ==
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS;
   if (error.state() == GoogleServiceAuthError::TWO_FACTOR ||
       (had_two_factor_error_ && invalid_gaia)) {
     had_two_factor_error_ = true;
     return;
   }
 
   SignOut();
 }
 
-void SigninManager::Observe(NotificationType type,
+void SigninManager::Observe(int type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
 #if !defined(OS_CHROMEOS)
-  DCHECK(type == NotificationType::TOKEN_AVAILABLE);
+  DCHECK(type == chrome::NOTIFICATION_TOKEN_AVAILABLE);
   TokenService::TokenAvailableDetails* tok_details =
       Details<TokenService::TokenAvailableDetails>(details).ptr();
 
   // If a GAIA service token has become available, use it to pre-login the
   // user to other services that depend on GAIA credentials.
   if (tok_details->service() == GaiaConstants::kGaiaService) {
     if (client_login_.get() == NULL) {
       client_login_.reset(new GaiaAuthFetcher(this,
                                               GaiaConstants::kChromeSource,
                                               profile_->GetRequestContext()));
     }
 
     client_login_->StartTokenAuth(tok_details->token());
 
     // We only want to do this once per sign-in.
     CleanupNotificationRegistration();
   }
 #endif
 }