New authorization framework for sync. ...

chrome/browser/net/gaia/token_service.cc

 // Copyright (c) 2010 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/string_util.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/net/gaia/gaia_authenticator2.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "chrome/common/notification_service.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::kSyncService,
                                          GaiaConstants::kTalkService};
 TokenService::TokenService()
     : token_loading_query_(NULL) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 }
 
 TokenService::~TokenService() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   ResetCredentialsInMemory();
 }
 
 void TokenService::Initialize(const char* const source,
                               Profile* profile) {
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
-
+  if (!source_.empty()) {
+    // Already initialized.
+    return;
+  }
   getter_ = profile->GetRequestContext();
   // Since the user can create a bookmark in incognito, sync may be running.
   // Thus we have to go for explicit access.
   web_data_service_ = profile->GetWebDataService(Profile::EXPLICIT_ACCESS);
   source_ = std::string(source);
+  registrar_.Add(this,
+                 NotificationType::TOKEN_UPDATED,
+                 NotificationService::AllSources());
 }
 
 void TokenService::ResetCredentialsInMemory() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   // Terminate any running fetchers. Callbacks will not return.
   for (int i = 0; i < kNumServices; i++) {
     fetchers_[i].reset();
   }
 
@@ skipping 92 matching lines @@
     const std::string& service,
     const GoogleServiceAuthError& error) {
 
   TokenRequestFailedDetails details(service, error);
   NotificationService::current()->Notify(
       NotificationType::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);
+}
+
 void TokenService::OnIssueAuthTokenSuccess(const std::string& service,
                                            const std::string& auth_token) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   LOG(INFO) << "Got an authorization token for " << service;
   token_map_[service] = auth_token;
   FireTokenAvailableNotification(service, auth_token);
   SaveAuthTokenToDB(service, auth_token);
 }
 
 void TokenService::OnIssueAuthTokenFailure(const std::string& service,
@@ skipping 11 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(
+      NotificationType::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++) {
     // OnIssueAuthTokenSuccess should come from the same thread.
     // If a token is already present in the map, it could only have
     // come from a DB read or from IssueAuthToken. Since we should never
     // fetch from the DB twice in a browser session, it must be from
     // OnIssueAuthTokenSuccess, which is a live fetcher.
     //
     // Network fetched tokens take priority over DB tokens, so exclude tokens
     // which have already been loaded by the fetcher.
     if (!in_memory_tokens->count(kServices[i]) &&
         db_tokens.count(kServices[i])) {
       std::string db_token = db_tokens.find(kServices[i])->second;
       if (!db_token.empty()) {
         LOG(INFO) << "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,
+                           const NotificationSource& source,
+                           const NotificationDetails& details) {
+  DCHECK(type == NotificationType::TOKEN_UPDATED);
+  TokenAvailableDetails* tok_details =
+      Details<TokenAvailableDetails>(details).ptr();
+  OnIssueAuthTokenSuccess(tok_details->service(), tok_details->token());
+}