[sync] Automatic bootstrapping of Sync on Win 8 from cached credentials

chrome/browser/signin/token_service.cc

 // Copyright (c) 2012 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/signin/token_service.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 105 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   credentials_ = credentials;
 
   SaveAuthTokenToDB(GaiaConstants::kGaiaLsid, credentials.lsid);
   SaveAuthTokenToDB(GaiaConstants::kGaiaSid, credentials.sid);
 
   // Cancel any currently running requests.
   for (size_t i = 0; i < arraysize(kServices); i++) {
     fetchers_[i].reset();
   }
+
+  // Notify the CredentialCacheService that a new lsid and sid are available.
+  FireCredentialsUpdatedNotification(credentials.lsid, credentials.sid);
 }
 
 void TokenService::UpdateCredentialsWithOAuth2(
     const GaiaAuthConsumer::ClientOAuthResult& credentials) {
   // Will be implemented once the ClientOAuth signin is complete.  Not called
   // yet by any code.
   NOTREACHED();
 }
 
 
@@ skipping 83 matching lines @@
 const std::string& TokenService::GetOAuth2LoginAccessToken() const {
   return GetTokenForService(GaiaConstants::kGaiaOAuth2LoginAccessToken);
 }
 
 // static
 void TokenService::GetServiceNamesForTesting(std::vector<std::string>* names) {
   names->resize(arraysize(kServices));
   std::copy(kServices, kServices + arraysize(kServices), names->begin());
 }
 
+void TokenService::FireCredentialsUpdatedNotification(
+    const std::string& lsid,
+    const std::string& sid) {
+  CredentialsUpdatedDetails details(lsid, sid);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_TOKEN_SERVICE_CREDENTIALS_UPDATED,
+      content::Source<TokenService>(this),
+      content::Details<const CredentialsUpdatedDetails>(&details));
+}
+
 // 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);
@@ skipping 149 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());
 }