Adding notifications for new sync types.

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 296 matching lines @@
   pref_service->RegisterBooleanPref(prefs::kSyncManaged,
                                     false,
                                     PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterStringPref(prefs::kEncryptionBootstrapToken,
                                    "",
                                    PrefService::UNSYNCABLE_PREF);
 
   pref_service->RegisterBooleanPref(prefs::kSyncAutofillProfile,
                                     enable_by_default,
                                     PrefService::UNSYNCABLE_PREF);
+
+  // We started prompting people about new data types starting with the
+  // rollout of TYPED_URLs - all previously launched data types are treated
+  // as if they are already acknowledged.
+  syncable::ModelTypeBitSet model_set;
+  model_set.set(syncable::BOOKMARKS);
+  model_set.set(syncable::PREFERENCES);
+  model_set.set(syncable::PASSWORDS);
+  model_set.set(syncable::AUTOFILL_PROFILE);
+  model_set.set(syncable::AUTOFILL);
+  model_set.set(syncable::THEMES);
+  model_set.set(syncable::EXTENSIONS);
+  model_set.set(syncable::NIGORI);
+  model_set.set(syncable::SEARCH_ENGINES);
+  model_set.set(syncable::APPS);
+  pref_service->RegisterStringPref(prefs::kAcknowledgedSyncTypes,

[akalin, 2011/08/02 20:16:53]

Wouldn't it better to have this as a List pref?

[Andrew T Wilson (Slow), 2011/08/02 22:07:42]

Not really - I really just want to serialize a ModelTypeBitSet. I don't really
want to treat this as a list itself, since I never interact with it as a list
(adding/removing items) - I always just do a wholesale replacement.

[akalin, 2011/08/04 01:26:06]

Yes, but it's conceivable that in the future that we may want to treat it as a
list.  It's not that much more effort to store it as a list so I'd still prefer
that.

You'd only have to change this to:

pref_service->RegisterListPref(prefs::kAcknowledgedSyncTypes,
syncable::ModelTypeBitSetToValue(model_set));

[Andrew T Wilson (Slow), 2011/08/07 02:45:38]

So, in the interest of getting this landed, I made this change even though I
disagree with it.

IMO, using a list pref here is not preferable to a string pref (the underlying
data type is fundamentally a set, not a list, and so serializing a set instead
of converting it to a list is a better solution).

+                                   syncable::ModelTypeBitSetToString(model_set),
+                                   PrefService::UNSYNCABLE_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 577 matching lines @@
   if (!backend_.get() &&
       unrecoverable_error_detected_ == false) {
     NOTREACHED();
     return;
   }
 
   profile_->GetPrefs()->SetBoolean(prefs::kKeepEverythingSynced,
       sync_everything);
 
   ChangePreferredDataTypes(chosen_types);
+  AcknowledgeSyncedTypes();
   profile_->GetPrefs()->ScheduleSavePersistentPrefs();
 }
 
 void ProfileSyncService::OnUserCancelledDialog() {
   if (!HasSyncSetupCompleted()) {
     // A sync dialog was aborted before authentication.
     // Rollback.
     expect_sync_configuration_aborted_ = true;
     DisableForUser();
   }
@@ skipping 432 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;
 }
+
+void ProfileSyncService::AcknowledgeSyncedTypes() {
+  syncable::ModelTypeBitSet acknowledged;
+  CHECK(syncable::ModelTypeBitSetFromString(
+      profile_->GetPrefs()->GetString(prefs::kAcknowledgedSyncTypes),
+      &acknowledged));
+  syncable::ModelTypeSet registered;
+  GetRegisteredDataTypes(&registered);
+  syncable::ModelTypeBitSet registered_bit_set =
+      syncable::ModelTypeBitSetFromSet(registered);
+
+  // Add the registered types to the current set of acknowledged types, and then
+  // store the resulting set in prefs.
+  acknowledged |= registered_bit_set;
+  profile_->GetPrefs()->SetString(

[akalin, 2011/08/04 01:26:06]

and here you'd just do:

scoped_ptr<ListValue>
acknowledged_list(syncable::ModelTypeBitSetToValue(acknowledge));
profile_->GetPrefs()->Set(prefs..., *acknowledged_list);

[Andrew T Wilson (Slow), 2011/08/07 02:45:38]

Done.

+      prefs::kAcknowledgedSyncTypes,
+      syncable::ModelTypeBitSetToString(acknowledged));
+  profile_->GetPrefs()->ScheduleSavePersistentPrefs();
+}
+
+string16 ProfileSyncService::GetSyncNotification() {
+  string16 promo;
+  if (HasSyncSetupCompleted() &&
+      profile_->GetPrefs()->GetBoolean(prefs::kKeepEverythingSynced)) {
+    // User is "syncing everything" - see if we've added any new data types.
+    syncable::ModelTypeBitSet acknowledged;
+    CHECK(syncable::ModelTypeBitSetFromString(

[akalin, 2011/08/04 01:26:06]

I guess here you'd have to write ModelTypeBitSetFromValue(), but that shouldn't
be too hard.

[Andrew T Wilson (Slow), 2011/08/07 02:45:38]

Done.

+        profile_->GetPrefs()->GetString(prefs::kAcknowledgedSyncTypes),
+        &acknowledged));
+    syncable::ModelTypeSet registered;
+    GetRegisteredDataTypes(&registered);
+    syncable::ModelTypeBitSet registered_bit_set =
+        syncable::ModelTypeBitSetFromSet(registered);
+
+    syncable::ModelTypeBitSet unacknowledged =
+        registered_bit_set & ~acknowledged;
+    // TODO(sync): As we add new data types, we'll probably need some more
+    // generic string to display to the user, since the method below won't
+    // scale indefinitely (we'd need N*(N+1)/2 different strings to represent
+    // all the combinations of unacknowledged types). But for now, we just
+    // have sessions and typed urls so this is OK.
+    if (unacknowledged.test(syncable::SESSIONS) &&
+        unacknowledged.test(syncable::TYPED_URLS)) {
+      return l10n_util::GetStringUTF16(IDS_SYNC_ADDED_SESSIONS_AND_TYPED_URLS);
+    } else if (unacknowledged.test(syncable::SESSIONS)) {
+      return l10n_util::GetStringUTF16(IDS_SYNC_ADDED_SESSIONS);
+    } else if (unacknowledged.test(syncable::TYPED_URLS)) {
+      return l10n_util::GetStringUTF16(IDS_SYNC_ADDED_TYPED_URLS);
+    } else {
+      // Shouldn't be possible for any other types to be unacknowledged.
+      DCHECK(!unacknowledged.any());
+    }
+  }
+  return promo;
+}
+