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

chrome/browser/net/gaia/token_service.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/net/gaia/token_service.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/gaia_auth_fetcher.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 #include "net/url_request/url_request_context_getter.h"
 
 // Unfortunately kNumServices must be defined in the .h.
 // TODO(chron): Sync doesn't use the TalkToken anymore so we can stop
 //              requesting it.
@@ skipping 39 matching lines @@
     std::string value = cmd_line->GetSwitchValueASCII(switches::kSetToken);
     int separator = value.find(':');
     std::string service = value.substr(0, separator);
     std::string token = value.substr(separator + 1);
     token_map_[service] = token;
     SaveAuthTokenToDB(service, token);
   }
 #endif
 
   registrar_.Add(this,
-                 NotificationType::TOKEN_UPDATED,
+                 chrome::NOTIFICATION_TOKEN_UPDATED,
                  NotificationService::AllSources());
 }
 
 void TokenService::ResetCredentialsInMemory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Terminate any running fetchers. Callbacks will not return.
   for (int i = 0; i < kNumServices; i++) {
     fetchers_[i].reset();
   }
@@ skipping 80 matching lines @@
 // It can fire once from the DB read, and then once from the initial
 // fetcher. Future fetches can cause more notification firings.
 // The DB read will not however fire a notification if the fetcher
 // returned first. So it's always safe to use the latest notification.
 void TokenService::FireTokenAvailableNotification(
     const std::string& service,
     const std::string& auth_token) {
 
   TokenAvailableDetails details(service, auth_token);
   NotificationService::current()->Notify(
-      NotificationType::TOKEN_AVAILABLE,
+      chrome::NOTIFICATION_TOKEN_AVAILABLE,
       Source<TokenService>(this),
       Details<const TokenAvailableDetails>(&details));
 }
 
 void TokenService::FireTokenRequestFailedNotification(
     const std::string& service,
     const GoogleServiceAuthError& error) {
 
   TokenRequestFailedDetails details(service, error);
   NotificationService::current()->Notify(
-      NotificationType::TOKEN_REQUEST_FAILED,
+      chrome::NOTIFICATION_TOKEN_REQUEST_FAILED,
       Source<TokenService>(this),
       Details<const TokenRequestFailedDetails>(&details));
 }
 
 void TokenService::IssueAuthTokenForTest(const std::string& service,
                                          const std::string& auth_token) {
   token_map_[service] = auth_token;
   FireTokenAvailableNotification(service, auth_token);
 }
 
@@ skipping 23 matching lines @@
   // load any tokens at all from the DB.
   if (result) {
     DCHECK(result->GetType() == TOKEN_RESULT);
     const WDResult<std::map<std::string, std::string> > * token_result =
         static_cast<const WDResult<std::map<std::string, std::string> > * > (
             result);
     LoadTokensIntoMemory(token_result->GetValue(), &token_map_);
   }
 
   NotificationService::current()->Notify(
-      NotificationType::TOKEN_LOADING_FINISHED,
+      chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
       Source<TokenService>(this),
       NotificationService::NoDetails());
 }
 
 // Load tokens from the db_token map into the in memory token map.
 void TokenService::LoadTokensIntoMemory(
     const std::map<std::string, std::string>& db_tokens,
     std::map<std::string, std::string>* in_memory_tokens) {
 
   for (int i = 0; i < kNumServices; i++) {
@@ skipping 11 matching lines @@
       if (!db_token.empty()) {
         VLOG(1) << "Loading " << kServices[i] << "token from DB: " << db_token;
         (*in_memory_tokens)[kServices[i]] = db_token;
         FireTokenAvailableNotification(kServices[i], db_token);
         // Failures are only for network errors.
       }
     }
   }
 }
 
-void TokenService::Observe(NotificationType type,
+void TokenService::Observe(int type,
                            const NotificationSource& source,
                            const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TOKEN_UPDATED);
+  DCHECK(type == chrome::NOTIFICATION_TOKEN_UPDATED);
   TokenAvailableDetails* tok_details =
       Details<TokenAvailableDetails>(details).ptr();
   OnIssueAuthTokenSuccess(tok_details->service(), tok_details->token());
 }