Create and remove sync nodes whenever preferences flip their managed flag

chrome/browser/sync/glue/preference_change_processor.cc

 // Copyright (c) 2010 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/glue/preference_change_processor.h"
 
 #include <set>
 #include <string>
 
+#include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sync/glue/preference_model_associator.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 
 namespace browser_sync {
 
 PreferenceChangeProcessor::PreferenceChangeProcessor(
     PreferenceModelAssociator* model_associator,
     UnrecoverableErrorHandler* error_handler)
     : ChangeProcessor(error_handler),
       pref_service_(NULL),
-      model_associator_(model_associator) {
+      model_associator_(model_associator),
+      processing_pref_change_(false) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(model_associator);
   DCHECK(error_handler);
 }
 
 PreferenceChangeProcessor::~PreferenceChangeProcessor() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 }
 
 void PreferenceChangeProcessor::Observe(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(running());
   DCHECK(NotificationType::PREF_CHANGED == type);
   DCHECK_EQ(pref_service_, Source<PrefService>(source).ptr());
 
+  // Avoid recursion.
+  if (processing_pref_change_)
+    return;
+
+  AutoReset<bool> guard(&processing_pref_change_, true);
   std::string* name = Details<std::string>(details).ptr();
   const PrefService::Preference* preference =
       pref_service_->FindPreference((*name).c_str());
   DCHECK(preference);
-
-  // TODO(mnissler): Detect preference->IsUserControlled() state changes here
-  // and call into PreferenceModelAssociator to associate/disassociate sync
-  // nodes when the state changes.
-
-  // Do not pollute sync data with values coming from policy, extensions or the
-  // commandline.
-  if (!preference->IsUserModifiable())
+  int64 sync_id = model_associator_->GetSyncIdFromChromeId(*name);
+  bool user_modifiable = preference->IsUserModifiable();
+  if (!user_modifiable) {
+    // We do not track preferences the user cannot change.
+    model_associator_->Disassociate(sync_id);
     return;
+  }
 
   sync_api::WriteTransaction trans(share_handle());
   sync_api::WriteNode node(&trans);
 
-  // Since we don't create sync nodes for preferences that still have
-  // their default values, this changed preference may not have a sync
-  // node yet.  If not, create it.
-  int64 sync_id = model_associator_->GetSyncIdFromChromeId(*name);
+  // Since we don't create sync nodes for preferences that are not under control
+  // of the user or still have their default value, this changed preference may
+  // not have a sync node yet. If so, we create a node. Similarly, a preference
+  // may become user-modifiable (e.g. due to laxer policy configuration), in
+  // which case we also need to create a sync node and associate it.
   if (sync_api::kInvalidId == sync_id) {
     sync_api::ReadNode root(&trans);
     if (!root.InitByTagLookup(browser_sync::kPreferencesTag)) {
       error_handler()->OnUnrecoverableError(FROM_HERE, "Can't find root.");
       return;
     }
 
-    if (!node.InitUniqueByCreation(syncable::PREFERENCES, root, *name)) {
-      error_handler()->OnUnrecoverableError(
-          FROM_HERE,
-          "Failed to create preference sync node.");
-      return;
+    // InitPrefNodeAndAssociate takes care of writing the value to the sync
+    // node if appropriate.
+    if (!model_associator_->InitPrefNodeAndAssociate(&trans,
+                                                     root,
+                                                     preference)) {
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+                                            "Can't create sync node.");
     }
+    return;
+  }
 
-    model_associator_->Associate(preference, node.GetId());
-  } else {
-    if (!node.InitByIdLookup(sync_id)) {
-      error_handler()->OnUnrecoverableError(FROM_HERE,
-                                            "Preference node lookup failed.");
-      return;
-    }
+  if (!node.InitByIdLookup(sync_id)) {
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+                                          "Preference node lookup failed.");
+    return;
   }
 
   if (!PreferenceModelAssociator::WritePreferenceToNode(
           preference->name(),
           *preference->GetValue(),
           &node)) {
     error_handler()->OnUnrecoverableError(FROM_HERE,
                                           "Failed to update preference node.");
     return;
   }
@@ skipping 112 matching lines @@
 void PreferenceChangeProcessor::StopObserving() {
   DCHECK(pref_service_);
   for (std::set<std::string>::const_iterator it =
       model_associator_->synced_preferences().begin();
       it != model_associator_->synced_preferences().end(); ++it) {
     pref_service_->RemovePrefObserver((*it).c_str(), this);
   }
 }
 
 }  // namespace browser_sync