Make NotificationService an interface in the content namespace, and switch callers to use it. Mov...

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 "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.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.
 const char* TokenService::kServices[] = {
   GaiaConstants::kGaiaService,
   GaiaConstants::kSyncService,
   GaiaConstants::kTalkService,
@@ skipping 195 matching lines @@
 // Note that this can fire twice or more for any given service.
 // 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(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_AVAILABLE,
       content::Source<TokenService>(this),
       content::Details<const TokenAvailableDetails>(&details));
 }
 
 void TokenService::FireTokenRequestFailedNotification(
     const std::string& service,
     const GoogleServiceAuthError& error) {
 
   TokenRequestFailedDetails details(service, error);
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_REQUEST_FAILED,
       content::Source<TokenService>(this),
       content::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 55 matching lines @@
   // If the fetch failed, there will be no result. In that case, we just don't
   // 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(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
       content::Source<TokenService>(this),
-      NotificationService::NoDetails());
+      content::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++) {
     // OnIssueAuthTokenSuccess should come from the same thread.
     // If a token is already present in the map, it could only have
@@ skipping 76 matching lines @@
 }
 
 void TokenService::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_TOKEN_UPDATED);
   TokenAvailableDetails* tok_details =
       content::Details<TokenAvailableDetails>(details).ptr();
   OnIssueAuthTokenSuccess(tok_details->service(), tok_details->token());
 }