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 55 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.
 
+namespace {

[akalin, 2011/08/11 18:03:37]

since this is used in 3 places, can you maybe move it to a helper function in
util/?

[Rick Campbell, 2011/08/11 21:04:08]

Done.

+bool IsUsingOAuth() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableSyncOAuth);
+}
+}
+
 ProfileSyncService::ProfileSyncService(ProfileSyncFactory* factory,
                                        Profile* profile,
                                        SigninManager* signin_manager,
                                        const std::string& cros_user)
     : last_auth_error_(AuthError::None()),
       passphrase_required_reason_(sync_api::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
       cros_user_(cros_user),
       sync_service_url_(kDevServerUrl),
@@ skipping 24 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;
-    }
+            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 68 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(
+      IsUsingOAuth() ?

[akalin, 2011/08/11 18:03:37]

this code is also repeated

[Rick Campbell, 2011/08/11 21:04:08]

Done.

+      GaiaConstants::kSyncServiceOAuth :
       GaiaConstants::kSyncService);
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_sync_data_folder) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
 
@@ skipping 964 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 (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 79 matching lines @@
             *profile_->GetPrefs()->GetList(prefs::kAcknowledgedSyncTypes));
     syncable::ModelTypeSet registered;
     GetRegisteredDataTypes(&registered);
     syncable::ModelTypeBitSet registered_bit_set =
         syncable::ModelTypeBitSetFromSet(registered);
     unacknowledged = registered_bit_set & ~acknowledged;
   }
   return unacknowledged;
 }