Sync: Remove NonBlockingDataTypeManager and any ProfileSyncService code related to it.

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 <vector>
 
@@ skipping 419 matching lines @@
 }
 
 void ProfileSyncService::UnregisterAuthNotifications() {
   if (signin())
     signin()->RemoveObserver(this);
   oauth2_token_service_->RemoveObserver(this);
 }
 
 void ProfileSyncService::RegisterDataTypeController(
     sync_driver::DataTypeController* data_type_controller) {
-  DCHECK_EQ(
-      directory_data_type_controllers_.count(data_type_controller->type()),
-      0U);
-  DCHECK(!GetRegisteredNonBlockingDataTypes().Has(
-      data_type_controller->type()));
-  directory_data_type_controllers_[data_type_controller->type()] =
-      data_type_controller;
-}
-
-void ProfileSyncService::RegisterNonBlockingType(syncer::ModelType type) {
-  DCHECK_EQ(directory_data_type_controllers_.count(type), 0U)
-      << "Duplicate registration of type " << ModelTypeToString(type);
-
-  // TODO(rlarocque): Set the enable flag properly when crbug.com/368834 is
-  // fixed and we have some way of telling whether or not this type should be
-  // enabled.
-  non_blocking_data_type_manager_.RegisterType(type, false);
-}
-
-void ProfileSyncService::InitializeNonBlockingType(
-    syncer::ModelType type,
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    const base::WeakPtr<syncer_v2::ModelTypeProcessorImpl>& type_processor) {
-  non_blocking_data_type_manager_.InitializeType(
-      type, task_runner, type_processor);
+  DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
+  data_type_controllers_[data_type_controller->type()] = data_type_controller;
 }
 
 bool ProfileSyncService::IsDataTypeControllerRunning(
     syncer::ModelType type) const {
   DataTypeController::TypeMap::const_iterator iter =
-      directory_data_type_controllers_.find(type);
-  if (iter == directory_data_type_controllers_.end()) {
+      data_type_controllers_.find(type);
+  if (iter == data_type_controllers_.end()) {
     return false;
   }
   return iter->second->state() == DataTypeController::RUNNING;
 }
 
 sync_driver::OpenTabsUIDelegate* ProfileSyncService::GetOpenTabsUIDelegate() {
   if (!IsDataTypeControllerRunning(syncer::SESSIONS))
     return NULL;
   return sessions_sync_manager_.get();
 }
@@ skipping 12 matching lines @@
   return device_info_sync_service_.get();
 }
 
 sync_driver::LocalDeviceInfoProvider*
 ProfileSyncService::GetLocalDeviceInfoProvider() const {
   return local_device_.get();
 }
 
 void ProfileSyncService::GetDataTypeControllerStates(
   DataTypeController::StateMap* state_map) const {
-    for (DataTypeController::TypeMap::const_iterator iter =
-         directory_data_type_controllers_.begin();
-         iter != directory_data_type_controllers_.end();
-         ++iter)
+  for (DataTypeController::TypeMap::const_iterator iter =
+           data_type_controllers_.begin();
+       iter != data_type_controllers_.end(); ++iter)
       (*state_map)[iter->first] = iter->second.get()->state();
 }
 
 SyncCredentials ProfileSyncService::GetCredentials() {
   SyncCredentials credentials;
   if (backend_mode_ == SYNC) {
     credentials.email = signin_->GetEffectiveUsername();
     DCHECK(!credentials.email.empty());
     credentials.sync_token = access_token_;
 
@@ skipping 338 matching lines @@
           FROM_HERE, base::Bind(&DeleteSyncDataFolder, directory_path_));
     }
     return;
   }
 
   if (reason == syncer::ShutdownReason::STOP_SYNC
       || reason == syncer::ShutdownReason::DISABLE_SYNC) {
     RemoveClientFromServer();
   }
 
-  non_blocking_data_type_manager_.DisconnectSyncBackend();
-
   // First, we spin down the backend to stop change processing as soon as
   // possible.
   base::Time shutdown_start_time = base::Time::Now();
   backend_->StopSyncingForShutdown();
 
   // Stop all data type controllers, if needed.  Note that until Stop
   // completes, it is possible in theory to have a ChangeProcessor apply a
   // change from a native model.  In that case, it will get applied to the sync
   // database (which doesn't get destroyed until we destroy the backend below)
   // as an unsynced change.  That will be persisted, and committed on restart.
-  if (directory_data_type_manager_) {
-    if (directory_data_type_manager_->state() != DataTypeManager::STOPPED) {
+  if (data_type_manager_) {
+    if (data_type_manager_->state() != DataTypeManager::STOPPED) {
       // When aborting as part of shutdown, we should expect an aborted sync
       // configure result, else we'll dcheck when we try to read the sync error.
       expect_sync_configuration_aborted_ = true;
-      directory_data_type_manager_->Stop();
+      data_type_manager_->Stop();
     }
-    directory_data_type_manager_.reset();
+    data_type_manager_.reset();
   }
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
   sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>());
 
   // Move aside the backend so nobody else tries to use it while we are
   // shutting it down.
   scoped_ptr<SyncBackendHost> doomed_backend(backend_.release());
@@ skipping 84 matching lines @@
 
 void ProfileSyncService::NotifySyncCycleCompleted() {
   FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_,
                     OnSyncCycleCompleted());
 }
 
 void ProfileSyncService::ClearStaleErrors() {
   ClearUnrecoverableError();
   last_actionable_error_ = SyncProtocolError();
   // Clear the data type errors as well.
-  if (directory_data_type_manager_.get())
-    directory_data_type_manager_->ResetDataTypeErrors();
-
+  if (data_type_manager_.get())
+    data_type_manager_->ResetDataTypeErrors();
 }
 
 void ProfileSyncService::ClearUnrecoverableError() {
   unrecoverable_error_reason_ = ERROR_REASON_UNSET;
   unrecoverable_error_message_.clear();
   unrecoverable_error_location_ = tracked_objects::Location();
 }
 
 // An invariant has been violated.  Transition to an error state where we try
 // to do as little work as possible, to avoid further corruption or crashes.
@@ skipping 27 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(
           &ProfileSyncService::ShutdownImpl, weak_factory_.GetWeakPtr(),
           delete_sync_database ? syncer::DISABLE_SYNC : syncer::STOP_SYNC));
 }
 
 void ProfileSyncService::ReenableDatatype(syncer::ModelType type) {
   if (!backend_initialized_)
     return;
-  directory_data_type_manager_->ReenableType(type);
+  data_type_manager_->ReenableType(type);
 }
 
 void ProfileSyncService::UpdateBackendInitUMA(bool success) {
   if (backend_mode_ != SYNC)
     return;
 
   is_first_time_sync_configure_ = !HasSyncSetupCompleted();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
@@ skipping 17 matching lines @@
 
   if (last_backup_time_) {
     DCHECK(device_info_sync_service_);
     device_info_sync_service_->UpdateLocalDeviceBackupTime(*last_backup_time_);
   }
 
   if (protocol_event_observers_.might_have_observers()) {
     backend_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 
-  non_blocking_data_type_manager_.ConnectSyncBackend(
-      backend_->GetSyncContextProxy());
-
   if (type_debug_info_observers_.might_have_observers()) {
     backend_->EnableDirectoryTypeDebugInfoForwarding();
   }
 
   // If we have a cached passphrase use it to decrypt/encrypt data now that the
   // backend is initialized. We want to call this before notifying observers in
   // case this operation affects the "passphrase required" status.
   ConsumeCachedPassphraseIfPossible();
 
   // The very first time the backend initializes is effectively the first time
@@ skipping 57 matching lines @@
 
   SigninClient* signin_client =
       ChromeSigninClientFactory::GetForProfile(profile_);
   DCHECK(signin_client);
   std::string signin_scoped_device_id =
       signin_client->GetSigninScopedDeviceId();
 
   // Initialize local device info.
   local_device_->Initialize(cache_guid, signin_scoped_device_id);
 
-  DVLOG(1) << "Setting preferred types for non-blocking DTM";
-  non_blocking_data_type_manager_.SetPreferredTypes(GetPreferredDataTypes());
-
   if (backend_mode_ == BACKUP || backend_mode_ == ROLLBACK)
     ConfigureDataTypeManager();
   else
     PostBackendInitialization();
 }
 
 void ProfileSyncService::OnSyncCycleCompleted() {
   UpdateLastSyncedTime();
   if (IsDataTypeControllerRunning(syncer::SESSIONS)) {
     // Trigger garbage collection of old sessions now that we've downloaded
@@ skipping 120 matching lines @@
   if (HasUnrecoverableError()) {
     // When unrecoverable error is detected we post a task to shutdown the
     // backend. The task might not have executed yet.
     return;
   }
 
   DVLOG(1) << "Passphrase required with reason: "
            << syncer::PassphraseRequiredReasonToString(reason);
   passphrase_required_reason_ = reason;
 
-  const syncer::ModelTypeSet types = GetPreferredDirectoryDataTypes();
-  if (directory_data_type_manager_) {
+  // TODO(stanisc): http://crbug.com/351005: Does this support USS types?
+  const syncer::ModelTypeSet types = GetPreferredDataTypes();
+  if (data_type_manager_) {
     // Reconfigure without the encrypted types (excluded implicitly via the
     // failed datatypes handler).
-    directory_data_type_manager_->Configure(types,
-                                            syncer::CONFIGURE_REASON_CRYPTO);
+    data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CRYPTO);
   }
 
-  // TODO(rlarocque): Support non-blocking types.  http://crbug.com/351005.
-
   // Notify observers that the passphrase status may have changed.
   NotifyObservers();
 }
 
 void ProfileSyncService::OnPassphraseAccepted() {
   DVLOG(1) << "Received OnPassphraseAccepted.";
 
   // If the pending keys were resolved via keystore, it's possible we never
   // consumed our cached passphrase. Clear it now.
   if (!cached_passphrase_.empty())
     cached_passphrase_.clear();
 
   // Reset passphrase_required_reason_ since we know we no longer require the
   // passphrase. We do this here rather than down in ResolvePassphraseRequired()
   // because that can be called by OnPassphraseRequired() if no encrypted data
   // types are enabled, and we don't want to clobber the true passphrase error.
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 
   // Make sure the data types that depend on the passphrase are started at
   // this time.
-  const syncer::ModelTypeSet types = GetPreferredDirectoryDataTypes();
-  if (directory_data_type_manager_) {
+  // TODO(stanisc): http://crbug.com/351005: Does this support USS types?
+  const syncer::ModelTypeSet types = GetPreferredDataTypes();
+  if (data_type_manager_) {
     // Re-enable any encrypted types if necessary.
-    directory_data_type_manager_->Configure(types,
-                                            syncer::CONFIGURE_REASON_CRYPTO);
+    data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CRYPTO);
   }
 
-  // TODO(rlarocque): Support non-blocking types.  http://crbug.com/351005.
-
   NotifyObservers();
 }
 
 void ProfileSyncService::OnEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DCHECK(encrypt_everything_allowed_ || !encrypt_everything_);
   DVLOG(1) << "Encrypted types changed to "
@@ skipping 11 matching lines @@
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(
     syncer::ModelTypeSet types) {
   DCHECK(backend_initialized_);
-  DCHECK(directory_data_type_manager_.get());
+  DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
   last_actionable_error_ = error;
   DCHECK_NE(last_actionable_error_.action,
             syncer::UNKNOWN_ACTION);
@@ skipping 66 matching lines @@
   // updated nigori state. Time to cache the nigori state, and catch up the
   // active data types.
   sync_prefs_.SetSavedNigoriStateForPassphraseEncryptionTransition(
       nigori_state);
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(true);
   BeginConfigureCatchUpBeforeClear();
 }
 
 void ProfileSyncService::BeginConfigureCatchUpBeforeClear() {
   DCHECK_EQ(backend_mode_, SYNC);
-  DCHECK(directory_data_type_manager_);
+  DCHECK(data_type_manager_);
   DCHECK(!saved_nigori_state_);
   saved_nigori_state_ =
       sync_prefs_.GetSavedNigoriStateForPassphraseEncryptionTransition().Pass();
   const syncer::ModelTypeSet types = GetActiveDataTypes();
   catch_up_configure_in_progress_ = true;
-  directory_data_type_manager_->Configure(types,
-                                          syncer::CONFIGURE_REASON_CATCH_UP);
+  data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CATCH_UP);
 }
 
 void ProfileSyncService::ClearAndRestartSyncForPassphraseEncryption() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   backend_->ClearServerData(base::Bind(
       &ProfileSyncService::OnClearServerDataDone, weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnClearServerDataDone() {
   DCHECK(sync_prefs_.GetPassphraseEncryptionTransitionInProgress());
@@ skipping 137 matching lines @@
   if (HasUnrecoverableError()) {
     return UNRECOVERABLE_ERROR;
   } else if (!backend_) {
     return NOT_ENABLED;
   } else if (backend_mode_ == BACKUP) {
     return BACKUP_USER_DATA;
   } else if (backend_mode_ == ROLLBACK) {
     return ROLLBACK_USER_DATA;
   } else if (backend_.get() && !HasSyncSetupCompleted()) {
     return SETUP_INCOMPLETE;
-  } else if (
-      backend_.get() && HasSyncSetupCompleted() &&
-      directory_data_type_manager_.get() &&
-      directory_data_type_manager_->state() == DataTypeManager::STOPPED) {
+  } else if (backend_ && HasSyncSetupCompleted() && data_type_manager_ &&
+             data_type_manager_->state() == DataTypeManager::STOPPED) {
     return DATATYPES_NOT_INITIALIZED;
   } else if (IsSyncActive()) {
     return INITIALIZED;
   }
   return UNKNOWN_ERROR;
 }
 
 std::string ProfileSyncService::QuerySyncStatusSummaryString() {
   SyncStatusSummary status = QuerySyncStatusSummary();
 
@@ skipping 63 matching lines @@
   if (!setup_in_progress && backend_initialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 bool ProfileSyncService::IsSyncAllowed() const {
   return IsSyncAllowedByFlag() && !IsManaged();
 }
 
 bool ProfileSyncService::IsSyncActive() const {
-  return backend_initialized_ && backend_mode_ == SYNC &&
-         directory_data_type_manager_ &&
-         directory_data_type_manager_->state() != DataTypeManager::STOPPED;
+  return backend_initialized_ && backend_mode_ == SYNC && data_type_manager_ &&
+         data_type_manager_->state() != DataTypeManager::STOPPED;
 }
 
 bool ProfileSyncService::IsSignedIn() const {
   // Sync is logged in if there is a non-empty effective account id.
   return !signin_->GetAccountIdToUse().empty();
 }
 
 bool ProfileSyncService::backend_initialized() const {
   return backend_initialized_;
 }
 
 ProfileSyncService::BackendMode ProfileSyncService::backend_mode() const {
   return backend_mode_;
 }
 
 bool ProfileSyncService::ConfigurationDone() const {
-  return directory_data_type_manager_ &&
-      directory_data_type_manager_->state() == DataTypeManager::CONFIGURED;
+  return data_type_manager_ &&
+         data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }
 
 bool ProfileSyncService::waiting_for_auth() const {
   return is_auth_in_progress_;
 }
 
 const syncer::Experiments& ProfileSyncService::current_experiments() const {
   return current_experiments_;
 }
 
@@ skipping 99 matching lines @@
     bool sync_everything,
     syncer::ModelTypeSet chosen_types) {
   if (!backend_.get() && !HasUnrecoverableError()) {
     NOTREACHED();
     return;
   }
 
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
-  if (directory_data_type_manager_.get())
-    directory_data_type_manager_->ResetDataTypeErrors();
+  if (data_type_manager_)
+    data_type_manager_->ResetDataTypeErrors();
   ChangePreferredDataTypes(chosen_types);
 }
 
 void ProfileSyncService::ChangePreferredDataTypes(
     syncer::ModelTypeSet preferred_types) {
 
   DVLOG(1) << "ChangePreferredDataTypes invoked";
   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();
-
-  // TODO(rlarocque): Reconfigure the NonBlockingDataTypeManager, too.  Blocked
-  // on crbug.com/368834.  Until that bug is fixed, it's difficult to tell
-  // which types should be enabled and when.
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const {
   if (!IsSyncActive() || !ConfigurationDone())
     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);
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   const syncer::ModelTypeSet preferred_types =
       sync_prefs_.GetPreferredDataTypes(registered_types);
   const syncer::ModelTypeSet enforced_types =
       Intersection(GetDataTypesFromPreferenceProviders(), registered_types);
   return Union(preferred_types, enforced_types);
 }
 
-syncer::ModelTypeSet
-ProfileSyncService::GetPreferredDirectoryDataTypes() const {
-  const syncer::ModelTypeSet registered_directory_types =
-      GetRegisteredDirectoryDataTypes();
-  const syncer::ModelTypeSet preferred_types =
-      sync_prefs_.GetPreferredDataTypes(registered_directory_types);
-  const syncer::ModelTypeSet enforced_types =
-      Intersection(GetDataTypesFromPreferenceProviders(),
-                   registered_directory_types);
-  return Union(preferred_types, enforced_types);
-}
-
-syncer::ModelTypeSet
-ProfileSyncService::GetPreferredNonBlockingDataTypes() const {
-  return sync_prefs_.GetPreferredDataTypes(GetRegisteredNonBlockingDataTypes());
-}
-
 syncer::ModelTypeSet ProfileSyncService::GetForcedDataTypes() const {
   // TODO(treib,zea): When SyncPrefs also implements SyncTypePreferenceProvider,
   // we'll need another way to distinguish user-choosable types from
   // programmatically-enabled types.
   return GetDataTypesFromPreferenceProviders();
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetRegisteredDataTypes() const {
-  return Union(GetRegisteredDirectoryDataTypes(),
-               GetRegisteredNonBlockingDataTypes());
-}
-
-syncer::ModelTypeSet
-ProfileSyncService::GetRegisteredDirectoryDataTypes() const {
   syncer::ModelTypeSet registered_types;
-  // The directory_data_type_controllers_ are determined by command-line flags;
+  // 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 =
-       directory_data_type_controllers_.begin();
-       it != directory_data_type_controllers_.end(); ++it) {
+           data_type_controllers_.begin();
+       it != data_type_controllers_.end(); ++it) {
     registered_types.Put(it->first);
   }
   return registered_types;
 }
 
-syncer::ModelTypeSet
-ProfileSyncService::GetRegisteredNonBlockingDataTypes() const {
-  return non_blocking_data_type_manager_.GetRegisteredTypes();
-}
-
 bool ProfileSyncService::IsUsingSecondaryPassphrase() const {
   syncer::PassphraseType passphrase_type = GetPassphraseType();
   return passphrase_type == syncer::FROZEN_IMPLICIT_PASSPHRASE ||
          passphrase_type == syncer::CUSTOM_PASSPHRASE;
 }
 
 syncer::PassphraseType ProfileSyncService::GetPassphraseType() const {
   return backend_->GetPassphraseType();
 }
 
 base::Time ProfileSyncService::GetExplicitPassphraseTime() const {
   return backend_->GetExplicitPassphraseTime();
 }
 
 bool ProfileSyncService::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   return backend_.get() && backend_->IsCryptographerReady(trans);
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
   // Don't configure datatypes if the setup UI is still on the screen - this
   // is to help multi-screen setting UIs (like iOS) where they don't want to
   // start syncing data until the user is done configuring encryption options,
   // etc. ReconfigureDatatypeManager() will get called again once the UI calls
   // SetSetupInProgress(false).
   if (backend_mode_ == SYNC && startup_controller_->setup_in_progress())
     return;
 
   bool restart = false;
-  if (!directory_data_type_manager_) {
+  if (!data_type_manager_) {
     restart = true;
-    directory_data_type_manager_.reset(
-        factory_->CreateDataTypeManager(debug_info_listener_,
-                                        &directory_data_type_controllers_,
-                                        this,
-                                        backend_.get(),
-                                        this));
+    data_type_manager_.reset(factory_->CreateDataTypeManager(
+        debug_info_listener_, &data_type_controllers_, this, backend_.get(),
+        this));
 
     // We create the migrator at the same time.
-    migrator_.reset(
-        new browser_sync::BackendMigrator(
-            profile_->GetDebugName(), GetUserShare(),
-            this, directory_data_type_manager_.get(),
-            base::Bind(&ProfileSyncService::StartSyncingWithServer,
-                       base::Unretained(this))));
+    migrator_.reset(new browser_sync::BackendMigrator(
+        profile_->GetDebugName(), GetUserShare(), this,
+        data_type_manager_.get(),
+        base::Bind(&ProfileSyncService::StartSyncingWithServer,
+                   base::Unretained(this))));
   }
 
   syncer::ModelTypeSet types;
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   if (backend_mode_ == BACKUP || backend_mode_ == ROLLBACK) {
     types = syncer::BackupTypes();
     reason = syncer::CONFIGURE_REASON_BACKUP_ROLLBACK;
   } else {
-    types = GetPreferredDirectoryDataTypes();
+    types = GetPreferredDataTypes();
     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;
     } else {
       // The user initiated a reconfiguration (either to add or remove types).
       reason = syncer::CONFIGURE_REASON_RECONFIGURATION;
     }
   }
 
-  directory_data_type_manager_->Configure(types, reason);
+  data_type_manager_->Configure(types, reason);
 }
 
 syncer::UserShare* ProfileSyncService::GetUserShare() const {
   if (backend_.get() && backend_initialized_) {
     return backend_->GetUserShare();
   }
   NOTREACHED();
   return NULL;
 }
 
@@ skipping 94 matching lines @@
       type_status->SetString("value", "Passive");
     } else if (throttled_types.Has(type) && passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive, Throttled");
     } else if (passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive");
     } else if (throttled_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Throttled");
-    } else if (GetRegisteredNonBlockingDataTypes().Has(type)) {
-      type_status->SetString("status", "ok");
-      type_status->SetString("value", "Non-Blocking");
     } else if (active_types.Has(type)) {
       type_status->SetString("status", "ok");
       type_status->SetString("value", "Active: " +
                              ModelSafeGroupToString(routing_info[type]));
     } else {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Disabled by User");
     }
 
     int live_count = detailed_status.num_entries_by_type[type] -
@@ skipping 315 matching lines @@
   if (awaiting_types_.Empty()) {
     callback_.Run(result_accumulator_.Pass());
     callback_.Reset();
   }
 }
 
 }  // namespace
 
 void ProfileSyncService::GetAllNodes(
     const base::Callback<void(scoped_ptr<base::ListValue>)>& callback) {
-  ModelTypeSet directory_types = GetRegisteredDirectoryDataTypes();
-  directory_types.PutAll(syncer::ControlTypes());
+  // TODO(stanisc): crbug.com/328606: Make this work for USS datatypes.
+  ModelTypeSet all_types = GetRegisteredDataTypes();
+  all_types.PutAll(syncer::ControlTypes());
   scoped_refptr<GetAllNodesRequestHelper> helper =
-      new GetAllNodesRequestHelper(directory_types, callback);
+      new GetAllNodesRequestHelper(all_types, callback);
 
   if (!backend_initialized_) {
     // If there's no backend available to fulfill the request, handle it here.
     ScopedVector<base::ListValue> empty_results;
     std::vector<ModelType> type_vector;
-    for (ModelTypeSet::Iterator it = directory_types.First();
-         it.Good(); it.Inc()) {
+    for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
       type_vector.push_back(it.Get());
       empty_results.push_back(new base::ListValue());
     }
     helper->OnReceivedNodesForTypes(type_vector, empty_results.Pass());
   } else {
     backend_->GetAllNodesForTypes(
-        directory_types,
+        all_types,
         base::Bind(&GetAllNodesRequestHelper::OnReceivedNodesForTypes, helper));
   }
 }
 
 bool ProfileSyncService::HasObserver(
     const sync_driver::SyncServiceObserver* observer) const {
   return observers_.HasObserver(observer);
 }
 
 base::WeakPtr<syncer::JsController> ProfileSyncService::GetJsController() {
@@ skipping 309 matching lines @@
 }
 
 std::string ProfileSyncService::unrecoverable_error_message() const {
   return unrecoverable_error_message_;
 }
 
 tracked_objects::Location ProfileSyncService::unrecoverable_error_location()
     const {
   return unrecoverable_error_location_;
 }