Make the change in ProfileSyncService such that it declares success

chrome/browser/sync/profile_sync_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/sync/profile_sync_service.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <map>
 #include <set>
@@ skipping 66 matching lines @@
 typedef GoogleServiceAuthError AuthError;
 
 const char* ProfileSyncService::kSyncServerUrl =
     "https://clients4.google.com/chrome-sync";
 
 const char* ProfileSyncService::kDevServerUrl =
     "https://clients4.google.com/chrome-sync/dev";
 
 static const int kSyncClearDataTimeoutInSeconds = 60;  // 1 minute.
 
+static const char* kRelevantTokenServices[] = {
+    GaiaConstants::kSyncService,
+    GaiaConstants::kGaiaOAuth2LoginRefreshToken};
+static const int kRelevantTokenServicesCount =
+    arraysize(kRelevantTokenServices);
+
+// Helper to check if the given token service is relevant for sync.
+static bool IsTokenServiceRelevant(const std::string& service) {
+  for (int i = 0; i < kRelevantTokenServicesCount; ++i) {
+    if (service == kRelevantTokenServices[i])
+      return true;
+  }
+  return false;
+}
 
 bool ShouldShowActionOnUI(
     const browser_sync::SyncProtocolError& error) {
   return (error.action != browser_sync::UNKNOWN_ACTION &&
           error.action != browser_sync::DISABLE_SYNC_ON_CLIENT);
 }
 
 ProfileSyncService::ProfileSyncService(ProfileSyncComponentsFactory* factory,
                                        Profile* profile,
                                        SigninManager* signin_manager,
@@ skipping 37 matching lines @@
   if (!cros_user_.empty())
     auto_start_enabled_ = true;
 }
 
 ProfileSyncService::~ProfileSyncService() {
   sync_prefs_.RemoveSyncPrefObserver(this);
   Shutdown(false);
 }
 
 bool ProfileSyncService::AreCredentialsAvailable() {
+  return AreCredentialsAvailable(false);
+}
+
+bool ProfileSyncService::AreCredentialsAvailable(
+    bool check_oauth_login_token) {
   if (IsManaged()) {
     return false;
   }
 
   // CrOS user is always logged in. Chrome uses signin_ to check logged in.
-  if (!cros_user_.empty() || !signin_->GetUsername().empty()) {
-    // TODO(chron): Verify CrOS unit test behavior.
-    return profile()->GetTokenService() &&
-        profile()->GetTokenService()->HasTokenForService(
-            browser_sync::SyncServiceName());
-  }
-  return false;
+  if (cros_user_.empty() && signin_->GetUsername().empty())
+    return false;
+
+  TokenService* token_service = profile()->GetTokenService();
+  if (!token_service)
+    return false;
+
+  // TODO(chron): Verify CrOS unit test behavior.
+  if (!token_service->HasTokenForService(browser_sync::SyncServiceName()))
+    return false;
+  return !check_oauth_login_token || token_service->HasOAuthLoginToken();
 }
 
 void ProfileSyncService::Initialize() {
   InitSettings();
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
   ClearStaleErrors();
 
@@ skipping 1262 matching lines @@
       }
       break;
     }
     case chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED: {
       GoogleServiceAuthError error =
           *(content::Details<const GoogleServiceAuthError>(details).ptr());
       UpdateAuthErrorState(error);
       break;
     }
     case chrome::NOTIFICATION_TOKEN_REQUEST_FAILED: {
-      GoogleServiceAuthError error(
-          GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
-      UpdateAuthErrorState(error);
+      const TokenService::TokenRequestFailedDetails& token_details =
+          *(content::Details<const TokenService::TokenRequestFailedDetails>(
+              details).ptr());
+      if (IsTokenServiceRelevant(token_details.service())) {
+        GoogleServiceAuthError error(
+            GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
+        UpdateAuthErrorState(error);
+      }
       break;
     }
     case chrome::NOTIFICATION_TOKEN_AVAILABLE: {
-      if (AreCredentialsAvailable()) {
+      const TokenService::TokenAvailableDetails& token_details =
+          *(content::Details<const TokenService::TokenAvailableDetails>(
+              details).ptr());
+      if (IsTokenServiceRelevant(token_details.service()) &&
+          AreCredentialsAvailable(true)) {
         if (backend_initialized_) {
           backend_->UpdateCredentials(GetCredentials());
         }
         if (!sync_prefs_.IsStartSuppressed())
           StartUp();
       }
       break;
     }
     case chrome::NOTIFICATION_TOKEN_LOADING_FINISHED: {
-      // If not in Chrome OS, and we have a username without tokens,
-      // the user will need to signin again, so sign out.
-      if (cros_user_.empty() &&
-          !signin_->GetUsername().empty() &&
-          !AreCredentialsAvailable()) {
+      // This notification gets fired when TokenService loads the tokens
+      // from storage. Here we only check if the chromiumsync token is
+      // available (versus both chromiumsync and oauth login tokens) to
+      // start up sync successfully for already logged in users who may
+      // only have chromiumsync token if they logged in before the code
+      // to generate oauth login token released.
+      if (AreCredentialsAvailable()) {
+        // Initialize the backend if sync token was loaded.
+        if (backend_initialized_) {
+          backend_->UpdateCredentials(GetCredentials());
+        }
+        if (!sync_prefs_.IsStartSuppressed())
+          StartUp();
+      } else if (cros_user_.empty() && !signin_->GetUsername().empty()) {
+        // If not in Chrome OS, and we have a username without tokens,
+        // the user will need to signin again, so sign out.
         DisableForUser();
       }
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
 
@@ skipping 81 matching lines @@
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }