Refactor preference syncing.

chrome/browser/prefs/pref_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/prefs/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/value_conversions.h"
 #include "build/build_config.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
 #include "chrome/browser/prefs/default_pref_store.h"
 #include "chrome/browser/prefs/overlay_persistent_pref_store.h"
+#include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/pref_notifier_impl.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/ui/profile_error_dialog.h"
 #include "chrome/common/json_pref_store.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
@@ skipping 106 matching lines @@
                          PrefStore* extension_prefs,
                          PrefStore* command_line_prefs,
                          PersistentPrefStore* user_prefs,
                          PrefStore* recommended_platform_prefs,
                          PrefStore* recommended_cloud_prefs,
                          DefaultPrefStore* default_store,
                          PrefServiceDelegate* delegate)
     : user_pref_store_(user_prefs),
       default_store_(default_store),
       delegate_(delegate) {
+  pref_sync_associator_.reset(new PrefModelAssociator(this));
   pref_notifier_.reset(new PrefNotifierImpl(this));
   pref_value_store_.reset(
       new PrefValueStore(managed_platform_prefs,
                          managed_cloud_prefs,
                          extension_prefs,
                          command_line_prefs,
                          user_pref_store_,
                          recommended_platform_prefs,
                          recommended_cloud_prefs,
                          default_store,
+                         pref_sync_associator_.get(),
                          pref_notifier_.get()));
   InitFromStorage();
 }
 
 PrefService::PrefService(const PrefService& original,
                          PrefStore* incognito_extension_prefs)
       : user_pref_store_(
             new OverlayPersistentPrefStore(original.user_pref_store_.get())),
         default_store_(original.default_store_.get()),
         delegate_(NULL) {
+  // Incognito mode doesn't sync, so no need to create PrefModelAssociator.
   pref_notifier_.reset(new PrefNotifierImpl(this));
   pref_value_store_.reset(original.pref_value_store_->CloneAndSpecialize(
       NULL, // managed_platform_prefs
       NULL, // managed_cloud_prefs
       incognito_extension_prefs,
       NULL, // command_line_prefs
       user_pref_store_.get(),
       NULL, // recommended_platform_prefs
       NULL, // recommended_cloud_prefs
       default_store_.get(),
+      NULL, // pref_sync_associator_
       pref_notifier_.get()));
   InitFromStorage();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
 
   // Reset pointers so accesses after destruction reliably crash.
   pref_value_store_.reset();
   user_pref_store_ = NULL;
   default_store_ = NULL;
+  if (pref_sync_associator_.get())
+    pref_sync_associator_->DisassociateModels();
+  pref_sync_associator_.reset();
 }
 
 void PrefService::OnPrefsRead(PersistentPrefStore::PrefReadError error,
                               bool no_dir) {
   if (no_dir) {
     // Bad news. When profile is created, the process that creates the directory
     // is explicitly started. So if directory is missing it probably means that
     // Chromium hasn't sufficient privileges.
     CHECK(delegate_);
     delegate_->OnPrefsLoaded(this, false);
@@ skipping 46 matching lines @@
 void PrefService::ScheduleSavePersistentPrefs() {
   DCHECK(CalledOnValidThread());
   user_pref_store_->ScheduleWritePrefs();
 }
 
 void PrefService::CommitPendingWrite() {
   DCHECK(CalledOnValidThread());
   user_pref_store_->CommitPendingWrite();
 }
 
+namespace {
+
+// If there's no g_browser_process or no local state, return true (for testing).
+bool IsLocalStatePrefService(PrefService* prefs){
+  return (!g_browser_process ||
+          !g_browser_process->local_state() ||
+          g_browser_process->local_state() == prefs);
+}
+
+// If there's no g_browser_process, return true (for testing).
+bool IsProfilePrefService(PrefService* prefs){
+  // TODO(zea): uncomment this once all preferences are only ever registered
+  // with either the local_state's pref service or the profile's pref service.
+  // return (!g_browser_process || g_browser_process->local_state() != prefs);
+  return true;
+}
+
+}  // namespace
+
+
+// Local State prefs.
 void PrefService::RegisterBooleanPref(const char* path,
                                       bool default_value) {
-  RegisterPreference(path, Value::CreateBooleanValue(default_value));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateBooleanValue(default_value),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterIntegerPref(const char* path, int default_value) {
-  RegisterPreference(path, Value::CreateIntegerValue(default_value));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateIntegerValue(default_value),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterDoublePref(const char* path, double default_value) {
-  RegisterPreference(path, Value::CreateDoubleValue(default_value));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateDoubleValue(default_value),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterStringPref(const char* path,
                                      const std::string& default_value) {
-  RegisterPreference(path, Value::CreateStringValue(default_value));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateStringValue(default_value),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterFilePathPref(const char* path,
                                        const FilePath& default_value) {
-  RegisterPreference(path, Value::CreateStringValue(default_value.value()));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateStringValue(default_value.value()),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterListPref(const char* path) {
-  RegisterPreference(path, new ListValue());
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     new ListValue(),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterListPref(const char* path, ListValue* default_value) {
-  RegisterPreference(path, default_value);
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     default_value,
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterDictionaryPref(const char* path) {
-  RegisterPreference(path, new DictionaryValue());
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     new DictionaryValue(),
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterDictionaryPref(const char* path,
                                          DictionaryValue* default_value) {
-  RegisterPreference(path, default_value);
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(path,
+                     default_value,
+                     UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterLocalizedBooleanPref(const char* path,
                                                int locale_default_message_id) {
-  RegisterPreference(
-      path,
-      CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id),
+      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterLocalizedIntegerPref(const char* path,
                                                int locale_default_message_id) {
-  RegisterPreference(
-      path,
-      CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id),
+      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterLocalizedDoublePref(const char* path,
                                               int locale_default_message_id) {
-  RegisterPreference(
-      path,
-      CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id),
+      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterLocalizedStringPref(const char* path,
                                               int locale_default_message_id) {
-  RegisterPreference(
-      path,
-      CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id));
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id),
+      UNSYNCABLE_PREF);
+}
+
+void PrefService::RegisterInt64Pref(const char* path, int64 default_value) {
+  // If this fails, the pref service in use is a profile pref service, so the
+  // sync status must be provided (see profile pref registration calls below).
+  DCHECK(IsLocalStatePrefService(this));
+  RegisterPreference(
+      path,
+      Value::CreateStringValue(base::Int64ToString(default_value)),
+      UNSYNCABLE_PREF);
+}
+
+// Profile prefs (must use the sync_status variable).
+void PrefService::RegisterBooleanPref(const char* path,
+                                      bool default_value,
+                                      PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateBooleanValue(default_value),
+                     sync_status);
+}
+
+void PrefService::RegisterIntegerPref(const char* path,
+                                      int default_value,
+                                      PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateIntegerValue(default_value),
+                     sync_status);
+}
+
+void PrefService::RegisterDoublePref(const char* path,
+                                     double default_value,
+                                     PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateDoubleValue(default_value),
+                     sync_status);
+}
+
+void PrefService::RegisterStringPref(const char* path,
+                                     const std::string& default_value,
+                                     PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateStringValue(default_value),
+                     sync_status);
+}
+
+void PrefService::RegisterFilePathPref(const char* path,
+                                       const FilePath& default_value,
+                                       PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path,
+                     Value::CreateStringValue(default_value.value()),
+                     sync_status);
+}
+
+void PrefService::RegisterListPref(const char* path,
+                                   PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path, new ListValue(), sync_status);
+}
+
+void PrefService::RegisterListPref(const char* path,
+                                   ListValue* default_value,
+                                   PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path, default_value, sync_status);
+}
+
+void PrefService::RegisterDictionaryPref(const char* path,
+                                         PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path, new DictionaryValue(), sync_status);
+}
+
+void PrefService::RegisterDictionaryPref(const char* path,
+                                         DictionaryValue* default_value,
+                                         PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(path, default_value, sync_status);
+}
+
+void PrefService::RegisterLocalizedBooleanPref(const char* path,
+                                               int locale_default_message_id,
+                                               PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_BOOLEAN,locale_default_message_id),
+      sync_status);
+}
+
+void PrefService::RegisterLocalizedIntegerPref(const char* path,
+                                               int locale_default_message_id,
+                                               PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id),
+      sync_status);
+}
+
+void PrefService::RegisterLocalizedDoublePref(const char* path,
+                                              int locale_default_message_id,
+                                              PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id),
+      sync_status);
+}
+
+void PrefService::RegisterLocalizedStringPref(const char* path,
+                                              int locale_default_message_id,
+                                              PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(
+      path,
+      CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id),
+      sync_status);
+}
+
+void PrefService::RegisterInt64Pref(const char* path,
+                                    int64 default_value,
+                                    PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreference(
+      path,
+      Value::CreateStringValue(base::Int64ToString(default_value)),
+      sync_status);
 }
 
 bool PrefService::GetBoolean(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   bool result = false;
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
@@ skipping 142 matching lines @@
 void PrefService::AddPrefObserver(const char* path,
                                   NotificationObserver* obs) {
   pref_notifier_->AddPrefObserver(path, obs);
 }
 
 void PrefService::RemovePrefObserver(const char* path,
                                      NotificationObserver* obs) {
   pref_notifier_->RemovePrefObserver(path, obs);
 }
 
-void PrefService::RegisterPreference(const char* path, Value* default_value) {
+void PrefService::RegisterPreference(const char* path,
+                                     Value* default_value,
+                                     PrefSyncStatus sync_status) {
   DCHECK(CalledOnValidThread());
 
   // The main code path takes ownership, but most don't. We'll be safe.
   scoped_ptr<Value> scoped_value(default_value);
 
   if (FindPreference(path)) {
     NOTREACHED() << "Tried to register duplicate pref " << path;
     return;
   }
 
   Value::ValueType orig_type = default_value->GetType();
   DCHECK(orig_type != Value::TYPE_NULL && orig_type != Value::TYPE_BINARY) <<
          "invalid preference type: " << orig_type;
 
   // Hand off ownership.
   default_store_->SetDefaultValue(path, scoped_value.release());
+
+  // Register with sync if necessary.
+  if (sync_status == SYNCABLE_PREF && pref_sync_associator_.get())
+    pref_sync_associator_->RegisterPref(path);
 }
 
 void PrefService::ClearPref(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
@@ skipping 38 matching lines @@
   }
   std::string result("0");
   bool rv = pref->GetValue()->GetAsString(&result);
   DCHECK(rv);
 
   int64 val;
   base::StringToInt64(result, &val);
   return val;
 }
 
-void PrefService::RegisterInt64Pref(const char* path, int64 default_value) {
-  RegisterPreference(
-      path, Value::CreateStringValue(base::Int64ToString(default_value)));
-}
-
 Value* PrefService::GetMutableUserPref(const char* path,
                                        Value::ValueType type) {
   CHECK(type == Value::TYPE_DICTIONARY || type == Value::TYPE_LIST);
   DCHECK(CalledOnValidThread());
   DLOG_IF(WARNING, IsManagedPreference(path)) <<
       "Attempt to change managed preference " << path;
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to get an unregistered pref: " << path;
@@ skipping 40 matching lines @@
   if (pref->GetType() != new_value->GetType()) {
     NOTREACHED() << "Trying to set pref " << path
                  << " of type " << pref->GetType()
                  << " to value of type " << new_value->GetType();
     return;
   }
 
   user_pref_store_->SetValue(path, owned_value.release());
 }
 
+SyncableService* PrefService::GetSyncableService() {
+  return pref_sync_associator_.get();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PrefService::Preference
 
 PrefService::Preference::Preference(const PrefService* service,
                                     const char* name,
                                     Value::ValueType type)
       : name_(name),
         type_(type),
         pref_service_(service) {
   DCHECK(name);
@@ skipping 43 matching lines @@
   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }