Unrevert "[Sync] Split GetPreferredTypes into GetActiveType...""

chrome/browser/sync/profile_sync_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/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 185 matching lines @@
 }
 
 bool ProfileSyncService::IsSyncTokenAvailable() {
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service)
     return false;
   return token_service->HasTokenForService(GaiaConstants::kSyncService);
 }
 #if defined(OS_ANDROID)
 bool ProfileSyncService::ShouldEnablePasswordSyncForAndroid() const {
-  const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
-  const syncer::ModelTypeSet preferred_types =
-      sync_prefs_.GetPreferredDataTypes(registered_types);
-  if (!preferred_types.Has(syncer::PASSWORDS))
+  if (!GetPreferredDataTypes().Has(syncer::PASSWORDS))
     return false;
   // If backend has not completed initializing we cannot check if the
   // cryptographer is ready.
   if (!sync_initialized())
     return false;
   // On Android we do not want to prompt user to enter a passphrase. If
   // passwords cannot be decrypted we just disable them.
   syncer::ReadTransaction trans(FROM_HERE, GetUserShare());
   return IsCryptographerReady(&trans);
 }
@@ skipping 36 matching lines @@
     return;
 
   // There was a bug where OnUserChoseDatatypes was not properly called on
   // configuration (see crbug.com/154940). We detect this by checking whether
   // kSyncKeepEverythingSynced has a default value. If so, and sync setup has
   // completed, it means sync was not properly configured, so we manually
   // set kSyncKeepEverythingSynced.
   PrefService* const pref_service = profile_->GetPrefs();
   if (!pref_service)
     return;
-  const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
-  if (sync_prefs_.GetPreferredDataTypes(registered_types).Size() > 1)
+  if (GetPreferredDataTypes().Size() > 1)
     return;
 
   const PrefService::Preference* keep_everything_synced =
       pref_service->FindPreference(prefs::kSyncKeepEverythingSynced);
   // This will be false if the preference was properly set or if it's controlled
   // by policy.
   if (!keep_everything_synced->IsDefaultValue())
     return;
 
   // kSyncKeepEverythingSynced was not properly set. Set it and the preferred
   // types now, before we configure.
   UMA_HISTOGRAM_COUNTS("Sync.DatatypePrefRecovery", 1);
   sync_prefs_.SetKeepEverythingSynced(true);
+  syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   sync_prefs_.SetPreferredDataTypes(registered_types,
                                     registered_types);
 }
 
 void ProfileSyncService::TryStart() {
   if (!IsSyncEnabledAndLoggedIn())
     return;
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service)
     return;
@@ skipping 262 matching lines @@
 
 void ProfileSyncService::OnDataTypeRequestsSyncStartup(
     syncer::ModelType type) {
   DCHECK(syncer::UserTypes().Has(type));
   if (backend_.get()) {
     DVLOG(1) << "A data type requested sync startup, but it looks like "
                 "something else beat it to the punch.";
     return;
   }
 
-  if (!GetPreferredDataTypes().Has(type)) {
+  if (!GetActiveDataTypes().Has(type)) {
     // We can get here as datatype SyncableServices are typically wired up
     // to the native datatype even if sync isn't enabled.
     DVLOG(1) << "Dropping sync startup request because type "
              << syncer::ModelTypeToString(type) << "not enabled.";
     return;
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSyncEnableDeferredStartup)) {
     DVLOG(2) << "Data type requesting sync startup: "
@@ skipping 565 matching lines @@
   // Re-enable passwords if we have disabled them.
   if (failed_datatypes_handler_.GetFailedTypes().Has(syncer::PASSWORDS) &&
       ShouldEnablePasswordSyncForAndroid()) {
     // Clear the data type errors.
     failed_datatypes_handler_.OnUserChoseDatatypes();
   }
 #endif
 
   // Make sure the data types that depend on the passphrase are started at
   // this time.
-  const syncer::ModelTypeSet types = GetPreferredDataTypes();
-
+  const syncer::ModelTypeSet types = GetActiveDataTypes();
   if (data_type_manager_) {
     // Unblock the data type manager if necessary.
     data_type_manager_->Configure(types,
                                   syncer::CONFIGURE_REASON_RECONFIGURATION);
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DVLOG(1) << "Encrypted types changed to "
            << syncer::ModelTypeSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
   DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
 
   // If sessions are encrypted, full history sync is not possible, and
   // delete directives are unnecessary.
-  if (GetPreferredDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
+  if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
       encrypted_types_.Has(syncer::SESSIONS)) {
     DisableBrokenDatatype(syncer::HISTORY_DELETE_DIRECTIVES,
                           FROM_HERE,
                           "Delete directives not supported with encryption.");
   }
 }
 
 void ProfileSyncService::OnEncryptionComplete() {
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
@@ skipping 246 matching lines @@
 
 bool ProfileSyncService::HasUnrecoverableError() const {
   return unrecoverable_error_reason_ != ERROR_REASON_UNSET;
 }
 
 bool ProfileSyncService::IsPassphraseRequired() const {
   return passphrase_required_reason_ !=
       syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 }
 
-// TODO(zea): Rename this IsPassphraseNeededFromUI and ensure it's used
-// appropriately (see http://crbug.com/91379).
 bool ProfileSyncService::IsPassphraseRequiredForDecryption() const {
   // If there is an encrypted datatype enabled and we don't have the proper
   // passphrase, we must prompt the user for a passphrase. The only way for the
   // user to avoid entering their passphrase is to disable the encrypted types.
   return IsEncryptedDatatypeEnabled() && IsPassphraseRequired();
 }
 
 string16 ProfileSyncService::GetLastSyncedTimeString() const {
   if (last_synced_time_.is_null())
     return l10n_util::GetStringUTF16(IDS_SYNC_TIME_NEVER);
@@ skipping 95 matching lines @@
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   const syncer::ModelTypeSet registered_preferred_types =
       Intersection(registered_types, preferred_types);
   sync_prefs_.SetPreferredDataTypes(registered_types,
                                     registered_preferred_types);
 
   // Now reconfigure the DTM.
   ReconfigureDatatypeManager();
 }
 
+syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const {
+  const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
+  const syncer::ModelTypeSet failed_types =
+      failed_datatypes_handler_.GetFailedTypes();
+  return Difference(preferred_types, failed_types);
+}
+
 syncer::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   const syncer::ModelTypeSet preferred_types =
       sync_prefs_.GetPreferredDataTypes(registered_types);
-  const syncer::ModelTypeSet failed_types =
-      failed_datatypes_handler_.GetFailedTypes();
-  return Difference(preferred_types, failed_types);
+  return preferred_types;
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetRegisteredDataTypes() const {
   syncer::ModelTypeSet registered_types;
   // The data_type_controllers_ are determined by command-line flags; that's
   // effectively what controls the values returned here.
   for (DataTypeController::TypeMap::const_iterator it =
        data_type_controllers_.begin();
        it != data_type_controllers_.end(); ++it) {
     registered_types.Put(it->first);
@@ skipping 62 matching lines @@
             profile_->GetDebugName(), GetUserShare(),
             this, data_type_manager_.get(),
             base::Bind(&ProfileSyncService::StartSyncingWithServer,
                        base::Unretained(this))));
   }
 
   // This is probably where we want to trigger configuration of priority
   // datatypes, but we need to resolve crbug.com/226195 first.
 
 #if defined(OS_ANDROID)
-  if (GetPreferredDataTypes().Has(syncer::PASSWORDS) &&
+  if (GetActiveDataTypes().Has(syncer::PASSWORDS) &&
       !ShouldEnablePasswordSyncForAndroid()) {
     DisableBrokenDatatype(syncer::PASSWORDS, FROM_HERE, "Not supported.");
   }
 #endif
 
-  const syncer::ModelTypeSet types = GetPreferredDataTypes();
   if (IsPassphraseRequiredForDecryption()) {
     // We need a passphrase still. We don't bother to attempt to configure
     // until we receive an OnPassphraseAccepted (which triggers a configure).
     DVLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
              << "because a passphrase required";
     NotifyObservers();
     return;
   }
+
+  const syncer::ModelTypeSet types = GetActiveDataTypes();
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   if (!HasSyncSetupCompleted()) {
     reason = syncer::CONFIGURE_REASON_NEW_CLIENT;
   } else if (restart) {
     // Datatype downloads on restart are generally due to newly supported
     // datatypes (although it's also possible we're picking up where a failed
     // previous configuration left off).
     // TODO(sync): consider detecting configuration recovery and setting
     // the reason here appropriately.
     reason = syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
@@ skipping 441 matching lines @@
 #if defined(ENABLE_MANAGED_USERS)
   if (ManagedUserService::ProfileIsManaged(profile_)) {
     DCHECK_EQ(std::string(), signin_->GetAuthenticatedUsername());
     return ManagedUserService::GetManagedUserPseudoEmail();
   }
 #endif
 
   return signin_->GetAuthenticatedUsername();
 }