[Sync] Refactor data type configuration/activation/deactivation

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 331 matching lines @@
       GaiaConstants::kSyncService);
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_sync_data_folder) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
 
-  syncable::ModelTypeSet types;
+  syncable::ModelTypeSet initial_types;
   // If sync setup hasn't finished, we don't want to initialize routing info
   // for any data types so that we don't download updates for types that the
   // user chooses not to sync on the first DownloadUpdatesCommand.
   if (HasSyncSetupCompleted()) {
-    GetPreferredDataTypes(&types);
+    GetPreferredDataTypes(&initial_types);
   }
 
   SyncCredentials credentials = GetCredentials();
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter(
       profile_->GetRequestContext());
 
   backend_->Initialize(
       this,
       WeakHandle<JsEventHandler>(sync_js_controller_.AsWeakPtr()),
       sync_service_url_,
-      types,
+      initial_types,
       credentials,
       delete_sync_data_folder);
 }
 
 void ProfileSyncService::CreateBackend() {
   backend_.reset(new SyncBackendHost(profile_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (HasPendingEncryptedTypes())
@@ skipping 792 matching lines @@
 void ProfileSyncService::GetModelSafeRoutingInfo(
     browser_sync::ModelSafeRoutingInfo* out) {
   if (backend_.get() && backend_initialized_) {
     backend_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 void ProfileSyncService::ActivateDataType(
-    DataTypeController* data_type_controller,
+    syncable::ModelType type, browser_sync::ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
   DCHECK(backend_initialized_);
-  backend_->ActivateDataType(data_type_controller, change_processor);
+  backend_->ActivateDataType(type, group, change_processor);
 }
 
-void ProfileSyncService::DeactivateDataType(
-    DataTypeController* data_type_controller,
-    ChangeProcessor* change_processor) {
+void ProfileSyncService::DeactivateDataType(syncable::ModelType type) {
   if (!backend_.get())
     return;
-  backend_->DeactivateDataType(data_type_controller, change_processor);
+  backend_->DeactivateDataType(type);
 }
 
 void ProfileSyncService::SetPassphrase(const std::string& passphrase,
                                        bool is_explicit,
                                        bool is_creation) {
   if (ShouldPushChanges() || IsPassphraseRequired()) {
     VLOG(1) << "Setting " << (is_explicit ? "explicit" : "implicit")
             << " passphrase" << (is_creation ? " for creation" : "");
     backend_->SetPassphrase(passphrase, is_explicit);
   } else {
@@ skipping 195 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;
 }