[Sync] Device info should be enabled by default

components/sync_driver/sync_prefs.cc

 // Copyright (c) 2012 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 "components/sync_driver/sync_prefs.h"
 
 #include "base/logging.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 48 matching lines @@
       prefs::kSyncKeepEverythingSynced,
       true,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   syncer::ModelTypeSet user_types = syncer::UserTypes();
 
   // Include proxy types as well, as they can be individually selected,
   // although they don't have sync representations.
   user_types.PutAll(syncer::ProxyTypes());
 
-  // Treat bookmarks specially.
+  // Treat bookmarks and device info specially.
   RegisterDataTypePreferredPref(registry, syncer::BOOKMARKS, true);
+  RegisterDataTypePreferredPref(registry, syncer::DEVICE_INFO, true);
   user_types.Remove(syncer::BOOKMARKS);
+  user_types.Remove(syncer::DEVICE_INFO);
 
   // These two prefs are set from sync experiment to enable enhanced bookmarks.
   registry->RegisterIntegerPref(
       prefs::kEnhancedBookmarksExperimentEnabled,
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   registry->RegisterStringPref(
       prefs::kEnhancedBookmarksExtensionId,
       std::string(),
@@ skipping 260 matching lines @@
       return prefs::kSyncArticles;
     case syncer::SUPERVISED_USER_SHARED_SETTINGS:
       return prefs::kSyncSupervisedUserSharedSettings;
     case syncer::DEVICE_INFO:
       return prefs::kSyncDeviceInfo;
     case syncer::WIFI_CREDENTIALS:
       return prefs::kSyncWifiCredentials;
     default:
       break;
   }
-  NOTREACHED();
+  NOTREACHED() << "Type is " << data_type;
   return NULL;
 }
 
 #if defined(OS_CHROMEOS)
 std::string SyncPrefs::GetSpareBootstrapToken() const {
   DCHECK(CalledOnValidThread());
   return pref_service_->GetString(prefs::kSyncSpareBootstrapToken);
 }
 
 void SyncPrefs::SetSpareBootstrapToken(const std::string& token) {
@@ skipping 84 matching lines @@
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 bool SyncPrefs::GetDataTypePreferred(syncer::ModelType type) const {
   DCHECK(CalledOnValidThread());
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return false;
   }
+
+  // Device info is always enabled.
+  if (pref_name == prefs::kSyncDeviceInfo)
+    return true;
+
   if (type == syncer::PROXY_TABS &&
       pref_service_->GetUserPrefValue(pref_name) == NULL &&
       pref_service_->IsUserModifiablePreference(pref_name)) {
     // If there is no tab sync preference yet (i.e. newly enabled type),
     // default to the session sync preference value.
     pref_name = GetPrefNameForDataType(syncer::SESSIONS);
   }
 
   return pref_service_->GetBoolean(pref_name);
 }
 
 void SyncPrefs::SetDataTypePreferred(syncer::ModelType type,
                                      bool is_preferred) {
   DCHECK(CalledOnValidThread());
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
+
+  // Device info is always preferred.
+  if (type == syncer::DEVICE_INFO)
+    return;
+
   pref_service_->SetBoolean(pref_name, is_preferred);
 }
 
 syncer::ModelTypeSet SyncPrefs::ResolvePrefGroups(
     syncer::ModelTypeSet registered_types,
     syncer::ModelTypeSet types) const {
   DCHECK(registered_types.HasAll(types));
   syncer::ModelTypeSet types_with_groups = types;
   for (PrefGroupsMap::const_iterator i = pref_groups_.begin();
        i != pref_groups_.end();
@@ skipping 12 matching lines @@
 
 void SyncPrefs::SetFirstSyncTime(base::Time time) {
   pref_service_->SetInt64(prefs::kSyncFirstSyncTime, time.ToInternalValue());
 }
 
 void SyncPrefs::ClearFirstSyncTime() {
   pref_service_->ClearPref(prefs::kSyncFirstSyncTime);
 }
 
 }  // namespace sync_driver