[Sync] Calculate active types and track catch up in DTMI not PSS.

components/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 "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 195 matching lines @@
       encrypt_everything_(false),
       encryption_pending_(false),
       configure_status_(DataTypeManager::UNKNOWN),
       oauth2_token_service_(init_params.oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
       last_get_token_error_(GoogleServiceAuthError::AuthErrorNone()),
       gaia_cookie_manager_service_(init_params.gaia_cookie_manager_service),
       network_resources_(new syncer::HttpBridgeNetworkResources),
       start_behavior_(init_params.start_behavior),
-      catch_up_configure_in_progress_(false),
       passphrase_prompt_triggered_by_version_(false),
       sync_enabled_weak_factory_(this),
       weak_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(sync_client_);
   std::string last_version = sync_prefs_.GetLastRunVersion();
   std::string current_version = PRODUCT_VERSION;
   sync_prefs_.SetLastRunVersion(current_version);
 
   // Check for a major version change. Note that the versions have format
@@ skipping 559 matching lines @@
 
   // Clear various state.
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   engine_initialized_ = false;
   cached_passphrase_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
-  catch_up_configure_in_progress_ = false;
   access_token_.clear();
   request_access_token_retry_timer_.Stop();
   last_snapshot_ = syncer::SyncCycleSnapshot();
   // Revert to "no auth error".
   if (last_auth_error_.state() != GoogleServiceAuthError::NONE)
     UpdateAuthErrorState(GoogleServiceAuthError::AuthErrorNone());
 
   NotifyObservers();
 
   // Mark this as a clean shutdown(without crash).
@@ skipping 506 matching lines @@
 }
 
 void ProfileSyncService::BeginConfigureCatchUpBeforeClear() {
   DCHECK(data_type_manager_);
   DCHECK(!saved_nigori_state_);
   saved_nigori_state_ =
       base::MakeUnique<syncer::SyncEncryptionHandler::NigoriState>();
   sync_prefs_.GetNigoriSpecificsForPassphraseTransition(
       &saved_nigori_state_->nigori_specifics);
   const syncer::ModelTypeSet types = GetActiveDataTypes();
-  catch_up_configure_in_progress_ = true;
   data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CATCH_UP);
 }
 
 void ProfileSyncService::ClearAndRestartSyncForPassphraseEncryption() {
   DCHECK(thread_checker_.CalledOnValidThread());
   engine_->ClearServerData(
       base::Bind(&ProfileSyncService::OnClearServerDataDone,
                  sync_enabled_weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 51 matching lines @@
   // First handle the abort case.
   if (configure_status_ == DataTypeManager::ABORTED &&
       expect_sync_configuration_aborted_) {
     DVLOG(0) << "ProfileSyncService::Observe Sync Configure aborted";
     expect_sync_configuration_aborted_ = false;
     return;
   }
 
   // Handle unrecoverable error.
   if (configure_status_ != DataTypeManager::OK) {
-    if (catch_up_configure_in_progress_) {
+    if (result.was_catch_up_configure) {
       // Record catchup configuration failure.
       UMA_HISTOGRAM_ENUMERATION(kClearServerDataEventsHistogramName,
                                 CLEAR_SERVER_DATA_CATCHUP_FAILED,
                                 CLEAR_SERVER_DATA_MAX);
     }
     // Something catastrophic had happened. We should only have one
     // error representing it.
     syncer::SyncError error = data_type_status_table_.GetUnrecoverableError();
     DCHECK(error.IsSet());
     std::string message =
@@ skipping 23 matching lines @@
   NotifyObservers();
 
   if (migrator_.get() && migrator_->state() != BackendMigrator::IDLE) {
     // Migration in progress.  Let the migrator know we just finished
     // configuring something.  It will be up to the migrator to call
     // StartSyncingWithServer() if migration is now finished.
     migrator_->OnConfigureDone(result);
     return;
   }
 
-  if (catch_up_configure_in_progress_) {
-    catch_up_configure_in_progress_ = false;
+  if (result.was_catch_up_configure) {
     ClearAndRestartSyncForPassphraseEncryption();
     return;
   }
 
   StartSyncingWithServer();
 }
 
 void ProfileSyncService::OnConfigureStart() {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_configure_start_time_ = base::Time::Now();
@@ skipping 281 matching lines @@
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   // Will only enable those types that are registered and preferred.
   sync_prefs_.SetPreferredDataTypes(registered_types, preferred_types);
 
   // Now reconfigure the DTM.
   ReconfigureDatatypeManager();
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!IsSyncActive() || !ConfigurationDone())
+  if (!data_type_manager_)
     return syncer::ModelTypeSet();
-  const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
-  const syncer::ModelTypeSet failed_types =
-      data_type_status_table_.GetFailedTypes();
-  return Difference(preferred_types, failed_types);
+  return data_type_manager_->GetActiveDataTypes();
 }
 
 syncer::SyncClient* ProfileSyncService::GetSyncClient() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return sync_client_.get();
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
@@ skipping 877 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync