[Sync] Avoid unnecessary DB rewrite for TokenService credentials that were just read from DB

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 329 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
       content::Source<TokenService>(this),
       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) {
+  // Ensure that there are no active fetchers at the time we first load
+  // tokens from the DB into memory.
+  for (size_t i = 0; i < arraysize(kServices); ++i) {
+    DCHECK(NULL == fetchers_[i].get());
+  }
 
   for (size_t i = 0; i < arraysize(kServices); i++) {
     LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens, kServices[i]);
   }
   LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
       GaiaConstants::kGaiaOAuth2LoginRefreshToken);
   LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
       GaiaConstants::kGaiaOAuth2LoginAccessToken);
 
   if (credentials_.lsid.empty() && credentials_.sid.empty()) {
     // Look for GAIA SID and LSID tokens.  If we have both, and the current
     // crendentials are empty, update the credentials.
     std::string lsid;
     std::string sid;
 
     if (db_tokens.count(GaiaConstants::kGaiaLsid) > 0)
       lsid = db_tokens.find(GaiaConstants::kGaiaLsid)->second;
 
     if (db_tokens.count(GaiaConstants::kGaiaSid) > 0)
       sid = db_tokens.find(GaiaConstants::kGaiaSid)->second;
 
     if (!lsid.empty() && !sid.empty()) {
-      UpdateCredentials(GaiaAuthConsumer::ClientLoginResult(sid,
-                                                            lsid,
-                                                            std::string(),
-                                                            std::string()));
+      credentials_ = GaiaAuthConsumer::ClientLoginResult(sid,
+                                                         lsid,
+                                                         std::string(),
+                                                         std::string());
     }
   }
 }
 
 void TokenService::LoadSingleTokenIntoMemory(
     const std::map<std::string, std::string>& db_tokens,
     std::map<std::string, std::string>* in_memory_tokens,
     const std::string& service) {
   // OnIssueAuthTokenSuccess should come from the same thread.
   // If a token is already present in the map, it could only have
@@ skipping 15 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());
 }