Refactor preference syncing.

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 23 matching lines @@
 #include "chrome/browser/sync/js_arg_list.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
-#include "content/common/notification_details.h"
-#include "content/common/notification_source.h"
-#include "content/common/notification_type.h"
+#include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/native_widget_types.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
 using sync_api::SyncCredentials;
 
@@ skipping 75 matching lines @@
   pref_sync_managed_.Init(prefs::kSyncManaged, profile_->GetPrefs(), this);
 
   // For now, the only thing we can do through policy is to turn sync off.
   if (IsManaged()) {
     DisableForUser();
     return;
   }
 
   RegisterAuthNotifications();
 
+  // This will synchronously trigger all new model associators to register
+  // themselves. We do this in initialize so that we can ensure all datatype
+  // controllers have been registered and to ensure any services we depend on
+  // have already been initialized.
+  NotificationService::current()->Notify(
+      NotificationType::PROFILE_SYNC_SERVICE_LOADING,
+      Source<ProfileSyncService>(this),
+      NotificationService::NoDetails());
+
   // In Chrome, we integrate a SigninManager which works with the sync
   // setup wizard to kick off the TokenService. CrOS does its own plumbing
   // for the TokenService.
   if (cros_user_.empty()) {
     // Will load tokens from DB and broadcast Token events after.
     // Note: We rely on signin_ != NULL unless !cros_user_.empty().
     signin_.reset(new SigninManager());
     signin_->Initialize(profile_);
   }
 
@@ skipping 84 matching lines @@
                      << "is invalid: " << value;
       }
     }
   }
 }
 
 void ProfileSyncService::RegisterPreferences() {
   PrefService* pref_service = profile_->GetPrefs();
   if (pref_service->FindPreference(prefs::kSyncLastSyncedTime))
     return;
-  pref_service->RegisterInt64Pref(prefs::kSyncLastSyncedTime, 0);
-  pref_service->RegisterBooleanPref(prefs::kSyncHasSetupCompleted, false);
-  pref_service->RegisterBooleanPref(prefs::kSyncSuppressStart, false);
+  pref_service->RegisterInt64Pref(prefs::kSyncLastSyncedTime,
+                                  0,
+                                  false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncHasSetupCompleted,
+                                    false,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncSuppressStart,
+                                    false,
+                                    false /* don't sync 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;
 #else
   bool enable_by_default =
       !pref_service->HasPrefPath(prefs::kSyncHasSetupCompleted);
 #endif
 
-  pref_service->RegisterBooleanPref(prefs::kSyncBookmarks, true);
-  pref_service->RegisterBooleanPref(prefs::kSyncPasswords, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncPreferences, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncAutofill, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncThemes, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncTypedUrls, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncExtensions, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncApps, enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncSessions, enable_by_default);
+  pref_service->RegisterBooleanPref(prefs::kSyncBookmarks,
+                                    true,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncPasswords,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncPreferences,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncAutofill,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncThemes,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncTypedUrls,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncExtensions,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncApps,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncSessions,
+                                    enable_by_default,
+                                    false /* don't sync pref */);
   pref_service->RegisterBooleanPref(prefs::kKeepEverythingSynced,
-      enable_by_default);
-  pref_service->RegisterBooleanPref(prefs::kSyncManaged, false);
-  pref_service->RegisterStringPref(prefs::kEncryptionBootstrapToken, "");
+                                    enable_by_default,
+                                    false /* don't sync pref */);
+  pref_service->RegisterBooleanPref(prefs::kSyncManaged,
+                                    false,
+                                    false /* don't sync pref */);
+  pref_service->RegisterStringPref(prefs::kEncryptionBootstrapToken,
+                                   "",
+                                   false /* don't sync pref */);
 
   pref_service->RegisterBooleanPref(prefs::kSyncAutofillProfile,
-      enable_by_default);
+                                    enable_by_default,
+                                    false /* don't sync pref */);
 }
 
 void ProfileSyncService::ClearPreferences() {
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->ClearPref(prefs::kSyncLastSyncedTime);
   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?
@@ skipping 776 matching lines @@
 void ProfileSyncService::SetAutofillMigrationDebugInfo(
     syncable::AutofillMigrationDebugInfo::PropertyToSet property_to_set,
     const syncable::AutofillMigrationDebugInfo& info) {
   if (backend_.get() && backend_initialized_) {
     backend_->SetAutofillMigrationDebugInfo(property_to_set, info);
   } else {
     NOTREACHED();
   }
 }
 
+void ProfileSyncService::RegisterModelAssociator(
+    browser_sync::NewAssociatorInterface* associator) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  syncable::ModelType model_type = associator->model_type();
+  if (data_type_controllers_.count(model_type) > 0) {
+    DCHECK(!data_type_controllers_[model_type]->model_associator());
+    data_type_controllers_[model_type]->set_model_associator(associator);
+
+    // TODO(zea): pass the generic change processor's pointer back to the model
+    // associator.
+  }
+}
+
 void ProfileSyncService::ActivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
   DCHECK(backend_initialized_);
-  change_processor->Start(profile(), backend_->GetUserShare());
-  backend_->ActivateDataType(data_type_controller, change_processor);
+  if (change_processor) {
+    backend_->ActivateDataType(data_type_controller, change_processor);
+  } else {
+    // New associator interface.
+    // TODO(zea): Remove change processor argument here once we have a generic
+    // change processor.
+    backend_->ActivateDataType(
+        data_type_controller,
+        data_type_controller->model_associator()->change_processor());
+  }
 }
 
 void ProfileSyncService::DeactivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
-  change_processor->Stop();
-  if (backend_.get())
+  if (!backend_.get())
+    return;
+  if (change_processor) {
     backend_->DeactivateDataType(data_type_controller, change_processor);
+  } else {
+    // New associator interface.
+    // TODO(zea): Remove change processor argument here once we have a generic
+    // change processor.
+    backend_->DeactivateDataType(
+        data_type_controller,
+        data_type_controller->model_associator()->change_processor());
+  }
 }
 
 void ProfileSyncService::SetPassphrase(const std::string& passphrase,
                                        bool is_explicit,
                                        bool is_creation) {
   if (ShouldPushChanges() || observed_passphrase_required_) {
     backend_->SetPassphrase(passphrase, is_explicit);
   } else {
     cached_passphrase_.value = passphrase;
     cached_passphrase_.is_explicit = is_explicit;
@@ skipping 173 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;
 }