Support Sync following Gaia OAuth authentication

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 <stddef.h>
 #include <map>
 #include <ostream>
 #include <set>
@@ skipping 99 matching lines @@
 }
 
 bool ProfileSyncService::AreCredentialsAvailable() {
   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.
-    if (profile()->GetTokenService() &&
+    return profile()->GetTokenService() &&
         profile()->GetTokenService()->HasTokenForService(
-            GaiaConstants::kSyncService)) {
-      return true;
-    }
+            SyncSetupWizard::IsUsingOAuth() ?
+            GaiaConstants::kSyncServiceOAuth :
+            GaiaConstants::kSyncService);
   }
   return false;
 }
 
 void ProfileSyncService::Initialize() {
   InitSettings();
   RegisterPreferences();
 
   // 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
@@ skipping 123 matching lines @@
 void ProfileSyncService::RegisterPreferences() {
   PrefService* pref_service = profile_->GetPrefs();
   if (pref_service->FindPreference(prefs::kSyncLastSyncedTime))
     return;
   pref_service->RegisterInt64Pref(prefs::kSyncLastSyncedTime,
                                   0,
                                   PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterBooleanPref(prefs::kSyncHasSetupCompleted,
                                     false,
                                     PrefService::UNSYNCABLE_PREF);
+  pref_service->RegisterBooleanPref(prefs::kSyncUsingOAuth,
+                                    false,
+                                    PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterBooleanPref(prefs::kSyncSuppressStart,
                                     false,
                                     PrefService::UNSYNCABLE_PREF);
 
   // If you've never synced before, or if you're using Chrome OS, all datatypes
   // are on by default.
   // TODO(nick): Perhaps a better model would be to always default to false,
   // and explicitly call SetDataTypes() when the user shows the wizard.
 #if defined(OS_CHROMEOS)
   bool enable_by_default = true;
@@ skipping 50 matching lines @@
   pref_service->ClearPref(prefs::kSyncHasSetupCompleted);
   pref_service->ClearPref(prefs::kEncryptionBootstrapToken);
 
   // TODO(nick): The current behavior does not clear e.g. prefs::kSyncBookmarks.
   // Is that really what we want?
   pref_service->ScheduleSavePersistentPrefs();
 }
 
 SyncCredentials ProfileSyncService::GetCredentials() {
   SyncCredentials credentials;
-  credentials.email = !cros_user_.empty() ? cros_user_ : signin_->GetUsername();
+  credentials.email = cros_user_.empty() ? signin_->GetUsername() : cros_user_;
   DCHECK(!credentials.email.empty());
   TokenService* service = profile_->GetTokenService();
   credentials.sync_token = service->GetTokenForService(
+      SyncSetupWizard::IsUsingOAuth() ?
+      GaiaConstants::kSyncServiceOAuth :
       GaiaConstants::kSyncService);
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_sync_data_folder) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
 
@@ skipping 946 matching lines @@
       break;
     }
     case chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL: {
       const GoogleServiceSigninSuccessDetails* successful =
           (Details<const GoogleServiceSigninSuccessDetails>(details).ptr());
       // We pass 'false' to SetPassphrase to denote that this is an implicit
       // request and shouldn't override an explicit one.  Thus, we either
       // update the implicit passphrase (idempotent if the passphrase didn't
       // actually change), or the user has an explicit passphrase set so this
       // becomes a no-op.
-      SetPassphrase(successful->password, false, true);
+      if (SyncSetupWizard::IsUsingOAuth()) {
+        // TODO(rickcam): Bug 92323: Fetch password through special Gaia request
+        DCHECK(successful->password.empty());
+        LOG(WARNING) << "Not initializing sync passphrase.";
+      } else {
+        SetPassphrase(successful->password, false, true);
+      }
       break;
     }
     case chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED: {
       GoogleServiceAuthError error =
           *(Details<const GoogleServiceAuthError>(details).ptr());
       UpdateAuthErrorState(error);
       break;
     }
     case chrome::NOTIFICATION_TOKEN_REQUEST_FAILED: {
       GoogleServiceAuthError error(
           GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
       UpdateAuthErrorState(error);
       break;
     }
     case chrome::NOTIFICATION_TOKEN_AVAILABLE: {
       if (AreCredentialsAvailable()) {
         if (backend_initialized_) {
           backend_->UpdateCredentials(GetCredentials());
         }
-
         if (!profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart))
           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() &&
@@ skipping 45 matching lines @@
   // is initialized, all enabled data types are consistent with one
   // another, and no unrecoverable error has transpired.
   if (unrecoverable_error_detected_)
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }