sync: Add support for separate Chrome OS user selectable types

Chrome OS is introducing a separate settings UI to control sync for
OS types like printers, OS settings, and Wi-Fi config. See
go/split-settings-sync for links to PRD and mocks.

* Add UserSelectableOsType for OS data types
* Add types for both OS preferences and printers. This CL does both
  because EnumSet requires at least 2 enum values and I want to add
  UserSelectableOsTypeSet for consistency with the browser enum set.
* Change SyncUserSettings to support the new types, as well as a
  "sync all OS types" control.
* Add new prefs for sync OS preferences and sync all OS types. There
  was an existing pref for sync printers that wasn't used -- now it
  is used.

Not everything is wrapped in #if defined(OS_CHROMEOS) because the
convention in the sync code seems to be that all ModelType values
and pref names are compiled on all platforms. However, all references
to UserSelectableOsType are ifdef'd to make it clear that "OS type"
is Chrome OS only.

Bug: 1013466
Test: added to components_unittests and sync_integration_tests
Change-Id: I1cd6f7e663c20dfb0f36c55d204b92ea19a73852
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1895755
Commit-Queue: James Cook <jamescook@chromium.org>
Reviewed-by: Marc Treib <treib@chromium.org>
Cr-Commit-Position: refs/heads/master@{#712216}

chrome/browser/sync/test/integration/enable_disable_test.cc

@@ -31,9 +31,15 @@ using syncer::ModelTypeSet;
 using syncer::ModelTypeToString;
 using syncer::ProxyTypes;
 using syncer::SyncPrefs;
+using syncer::SyncUserSettings;
 using syncer::UserSelectableType;
 using syncer::UserSelectableTypeSet;
 
+#if defined(OS_CHROMEOS)
+using syncer::UserSelectableOsType;
+using syncer::UserSelectableOsTypeSet;
+#endif
+
 const char kSyncedBookmarkURL[] = "http://www.mybookmark.com";
 // Non-utf8 string to make sure it gets handled well.
 const char kTestServerChips[] = "\xed\xa0\x80\xed\xbf\xbf";
@@ -57,6 +63,11 @@ ModelTypeSet MultiGroupTypes(const ModelTypeSet& registered_types) {
       }
     }
   }
+#if defined(OS_CHROMEOS)
+  // Printers are migrating from browser UserSelectableType::kPreferences to a
+  // new UserSelectableOsType::kPrinters.
+  multi.Put(ModelType::PRINTERS);
+#endif
   multi.RetainAll(registered_types);
   return multi;
 }
@@ -117,6 +128,10 @@ class EnableDisableSingleClientTest : public SyncTest {
  protected:
   void SetupTest(bool all_types_enabled) {
     ASSERT_TRUE(SetupClients());
+#if defined(OS_CHROMEOS)
+    GetSyncService(0)->GetUserSettings()->SetSelectedOsTypes(
+        /*sync_all_os_types=*/all_types_enabled, UserSelectableOsTypeSet());
+#endif
     if (all_types_enabled) {
       ASSERT_TRUE(GetClient(0)->SetupSync());
     } else {
@@ -206,6 +221,15 @@ IN_PROC_BROWSER_TEST_F(EnableDisableSingleClientTest, DisableOneAtATime) {
     }
   }
 
+#if defined(OS_CHROMEOS)
+  // Printers are migrating from browser UserSelectableType::kPreferences to a
+  // new UserSelectableOsType::kPrinters. Manually disable the type.
+  SyncUserSettings* settings = GetClient(0)->service()->GetUserSettings();
+  UserSelectableOsTypeSet os_types = settings->GetSelectedOsTypes();
+  os_types.Remove(UserSelectableOsType::kPrinters);
+  settings->SetSelectedOsTypes(/*sync_all_os_types=*/false, os_types);
+#endif
+
   // Lastly make sure that all the multi grouped times are all gone, since we
   // did not check these after disabling inside the above loop.
   for (ModelType multi_grouped_type : multi_grouped_types_) {

chrome/browser/sync/test/integration/single_client_os_preferences_sync_test.cc

+// Copyright 2019 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 "ash/public/cpp/ash_pref_names.h"
+#include "ash/public/cpp/shelf_prefs.h"
+#include "base/macros.h"
+#include "base/test/scoped_feature_list.h"
+#include "chrome/browser/sync/test/integration/preferences_helper.h"
+#include "chrome/browser/sync/test/integration/sync_test.h"
+#include "chrome/browser/sync/test/integration/updated_progress_marker_checker.h"
+#include "chromeos/constants/chromeos_features.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using preferences_helper::ChangeStringPref;
+using preferences_helper::StringPrefMatches;
+
+namespace {
+
+class SingleClientOsPreferencesSyncTest : public SyncTest {
+ public:
+  SingleClientOsPreferencesSyncTest() : SyncTest(SINGLE_CLIENT) {
+    settings_feature_list_.InitAndEnableFeature(
+        chromeos::features::kSplitSettingsSync);
+  }
+
+  ~SingleClientOsPreferencesSyncTest() override = default;
+
+ private:
+  // The names |scoped_feature_list_| and |feature_list_| are both used in
+  // superclasses.
+  base::test::ScopedFeatureList settings_feature_list_;
+
+  DISALLOW_COPY_AND_ASSIGN(SingleClientOsPreferencesSyncTest);
+};
+
+IN_PROC_BROWSER_TEST_F(SingleClientOsPreferencesSyncTest, Sanity) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+
+  // Shelf alignment is a Chrome OS only preference.
+  ASSERT_TRUE(StringPrefMatches(ash::prefs::kShelfAlignment));
+  ChangeStringPref(/*profile_index=*/0, ash::prefs::kShelfAlignment,
+                   ash::kShelfAlignmentRight);
+  ASSERT_TRUE(UpdatedProgressMarkerChecker(GetSyncService(0)).Wait());
+  EXPECT_TRUE(StringPrefMatches(ash::prefs::kShelfAlignment));
+}
+
+}  // namespace

chrome/browser/sync/test/integration/two_client_os_preferences_sync_test.cc

+// Copyright 2019 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 "ash/public/cpp/ash_pref_names.h"
+#include "ash/public/cpp/shelf_prefs.h"
+#include "base/macros.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/metrics/histogram_tester.h"
+#include "base/test/scoped_feature_list.h"
+#include "chrome/browser/sync/test/integration/preferences_helper.h"
+#include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
+#include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
+#include "chrome/browser/sync/test/integration/sync_test.h"
+#include "chromeos/constants/chromeos_features.h"
+#include "components/prefs/pref_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using preferences_helper::ChangeStringPref;
+using preferences_helper::ClearPref;
+using preferences_helper::GetPrefs;
+using preferences_helper::GetRegistry;
+
+namespace {
+
+class TwoClientOsPreferencesSyncTest : public SyncTest {
+ public:
+  TwoClientOsPreferencesSyncTest() : SyncTest(TWO_CLIENT) {
+    settings_feature_list_.InitAndEnableFeature(
+        chromeos::features::kSplitSettingsSync);
+  }
+
+  ~TwoClientOsPreferencesSyncTest() override = default;
+
+  // Needed for AwaitQuiescence().
+  bool TestUsesSelfNotifications() override { return true; }
+
+ private:
+  // The names |scoped_feature_list_| and |feature_list_| are both used in
+  // superclasses.
+  base::test::ScopedFeatureList settings_feature_list_;
+
+  DISALLOW_COPY_AND_ASSIGN(TwoClientOsPreferencesSyncTest);
+};
+
+IN_PROC_BROWSER_TEST_F(TwoClientOsPreferencesSyncTest, E2E_ENABLED(Sanity)) {
+  ResetSyncForPrimaryAccount();
+  DisableVerifier();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  // Wait until sync settles before we override the prefs below.
+  ASSERT_TRUE(AwaitQuiescence());
+
+  // Shelf alignment is a Chrome OS only preference.
+  ASSERT_TRUE(StringPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+
+  base::HistogramTester histogram_tester;
+  ChangeStringPref(0, ash::prefs::kShelfAlignment, ash::kShelfAlignmentRight);
+  ASSERT_TRUE(StringPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+  for (int i = 0; i < num_clients(); ++i) {
+    ASSERT_EQ(ash::kShelfAlignmentRight,
+              GetPrefs(i)->GetString(ash::prefs::kShelfAlignment));
+  }
+
+  EXPECT_EQ(0, histogram_tester.GetBucketCount(
+                   "Sync.ModelTypeEntityChange3.OS_PREFERENCE",
+                   /*REMOTE_INITIAL_UPDATE=*/5));
+  // Client 0 may or may not see its own reflection during the test, but at
+  // least client 1 should have received one update.
+  EXPECT_NE(0, histogram_tester.GetBucketCount(
+                   "Sync.ModelTypeEntityChange3.OS_PREFERENCE",
+                   /*REMOTE_NON_INITIAL_UPDATE=*/4));
+  EXPECT_NE(
+      0U,
+      histogram_tester
+          .GetAllSamples(
+              "Sync.NonReflectionUpdateFreshnessPossiblySkewed2.OS_PREFERENCE")
+          .size());
+  EXPECT_NE(
+      0U, histogram_tester
+              .GetAllSamples("Sync.NonReflectionUpdateFreshnessPossiblySkewed2")
+              .size());
+}
+
+IN_PROC_BROWSER_TEST_F(TwoClientOsPreferencesSyncTest,
+                       E2E_ENABLED(Bidirectional)) {
+  ResetSyncForPrimaryAccount();
+  ASSERT_TRUE(SetupSync());
+
+  ASSERT_TRUE(StringPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+
+  ChangeStringPref(0, ash::prefs::kShelfAlignment, ash::kShelfAlignmentRight);
+  ASSERT_TRUE(StringPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+  EXPECT_EQ(ash::kShelfAlignmentRight,
+            GetPrefs(0)->GetString(ash::prefs::kShelfAlignment));
+
+  ChangeStringPref(1, ash::prefs::kShelfAlignment, ash::kShelfAlignmentLeft);
+  ASSERT_TRUE(StringPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+  EXPECT_EQ(ash::kShelfAlignmentLeft,
+            GetPrefs(0)->GetString(ash::prefs::kShelfAlignment));
+}
+
+IN_PROC_BROWSER_TEST_F(TwoClientOsPreferencesSyncTest, E2E_ENABLED(ClearPref)) {
+  ResetSyncForPrimaryAccount();
+  ASSERT_TRUE(SetupSync());
+  ChangeStringPref(0, ash::prefs::kShelfAlignment, ash::kShelfAlignmentRight);
+  ASSERT_TRUE(StringPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+
+  ClearPref(0, ash::prefs::kShelfAlignment);
+
+  ASSERT_TRUE(ClearedPrefMatchChecker(ash::prefs::kShelfAlignment).Wait());
+}
+
+}  // namespace

chrome/test/BUILD.gn

@@ -6109,8 +6109,10 @@ if (!is_android && !is_fuchsia) {
     if (is_chromeos) {
       sources += [
         "../browser/sync/test/integration/single_client_arc_package_sync_test.cc",
+        "../browser/sync/test/integration/single_client_os_preferences_sync_test.cc",
         "../browser/sync/test/integration/single_client_printers_sync_test.cc",
         "../browser/sync/test/integration/two_client_arc_package_sync_test.cc",
+        "../browser/sync/test/integration/two_client_os_preferences_sync_test.cc",
         "../browser/sync/test/integration/two_client_printers_sync_test.cc",
       ]
     }

components/sync/base/BUILD.gn

@@ -89,6 +89,10 @@ jumbo_static_library("base") {
     "//net",
     "//third_party/zlib",
   ]
+
+  if (is_chromeos) {
+    deps += [ "//chromeos/constants" ]
+  }
 }
 
 static_library("test_support") {

components/sync/base/DEPS

 include_rules = [
+  "+chromeos/constants",
   "+components/invalidation",
   "+components/os_crypt",
   "+components/pref_registry",

components/sync/base/pref_names.cc

@@ -27,6 +27,13 @@ const char kSyncFirstSetupComplete[] = "sync.has_setup_completed";
 // (kSyncBookmarks, kSyncPasswords, etc.) can all be ignored.
 const char kSyncKeepEverythingSynced[] = "sync.keep_everything_synced";
 
+#if defined(OS_CHROMEOS)
+// Boolean specifying whether to automatically sync all Chrome OS specific data
+// types (including future ones). This includes types like printers, OS-only
+// settings, etc. If set, the individual type preferences can be ignored.
+const char kSyncAllOsTypes[] = "sync.all_os_types";
+#endif
+
 // Booleans specifying whether the user has selected to sync the following
 // datatypes.
 const char kSyncAppList[] = "sync.app_list";
@@ -48,6 +55,7 @@ const char kSyncFaviconImages[] = "sync.favicon_images";
 const char kSyncFaviconTracking[] = "sync.favicon_tracking";
 const char kSyncHistoryDeleteDirectives[] = "sync.history_delete_directives";
 const char kSyncMountainShares[] = "sync.mountain_shares";
+const char kSyncOsPreferences[] = "sync.os_preferences";
 const char kSyncPasswords[] = "sync.passwords";
 const char kSyncPreferences[] = "sync.preferences";
 const char kSyncPrinters[] = "sync.printers";

components/sync/base/pref_names.h

@@ -17,6 +17,10 @@ extern const char kSyncPollIntervalSeconds[];
 extern const char kSyncFirstSetupComplete[];
 extern const char kSyncKeepEverythingSynced[];
 
+#if defined(OS_CHROMEOS)
+extern const char kSyncAllOsTypes[];
+#endif
+
 extern const char kSyncAppList[];
 extern const char kSyncAppNotifications[];
 extern const char kSyncAppSettings[];
@@ -36,6 +40,7 @@ extern const char kSyncFaviconImages[];
 extern const char kSyncFaviconTracking[];
 extern const char kSyncHistoryDeleteDirectives[];
 extern const char kSyncMountainShares[];
+extern const char kSyncOsPreferences[];
 extern const char kSyncPasswords[];
 extern const char kSyncPreferences[];
 extern const char kSyncPriorityPreferences[];

components/sync/base/sync_prefs.cc

@@ -19,6 +19,7 @@
 #include "components/prefs/pref_service.h"
 #include "components/reading_list/features/reading_list_buildflags.h"
 #include "components/sync/base/pref_names.h"
+#include "components/sync/base/user_selectable_type.h"
 
 namespace syncer {
 
@@ -125,6 +126,19 @@ const char* GetPrefNameForType(UserSelectableType type) {
   return nullptr;
 }
 
+#if defined(OS_CHROMEOS)
+const char* GetPrefNameForOsType(UserSelectableOsType type) {
+  switch (type) {
+    case UserSelectableOsType::kOsPreferences:
+      return prefs::kSyncOsPreferences;
+    case UserSelectableOsType::kPrinters:
+      return prefs::kSyncPrinters;
+  }
+  NOTREACHED();
+  return nullptr;
+}
+#endif  // defined(OS_CHROMEOS)
+
 // Gets an offset to add noise to the birth year. If not present in prefs, the
 // offset will be randomly generated within the offset range and cached in
 // syncable prefs.
@@ -270,6 +284,12 @@ void SyncPrefs::RegisterProfilePrefs(
   for (UserSelectableType type : UserSelectableTypeSet::All()) {
     RegisterTypeSelectedPref(registry, type);
   }
+#if defined(OS_CHROMEOS)
+  registry->RegisterBooleanPref(prefs::kSyncAllOsTypes, true);
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    registry->RegisterBooleanPref(GetPrefNameForOsType(type), false);
+  }
+#endif
 
   // Internal or bookkeeping prefs.
   registry->RegisterStringPref(prefs::kSyncCacheGuid, std::string());
@@ -467,6 +487,44 @@ void SyncPrefs::SetSelectedTypes(bool keep_everything_synced,
   }
 }
 
+#if defined(OS_CHROMEOS)
+bool SyncPrefs::IsSyncAllOsTypesEnabled() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return pref_service_->GetBoolean(prefs::kSyncAllOsTypes);
+}
+
+UserSelectableOsTypeSet SyncPrefs::GetSelectedOsTypes() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (IsSyncAllOsTypesEnabled()) {
+    return UserSelectableOsTypeSet::All();
+  }
+  UserSelectableOsTypeSet selected_types;
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    const char* pref_name = GetPrefNameForOsType(type);
+    DCHECK(pref_name);
+    if (pref_service_->GetBoolean(pref_name)) {
+      selected_types.Put(type);
+    }
+  }
+  return selected_types;
+}
+
+void SyncPrefs::SetSelectedOsTypes(bool sync_all_os_types,
+                                   UserSelectableOsTypeSet registered_types,
+                                   UserSelectableOsTypeSet selected_types) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  pref_service_->SetBoolean(prefs::kSyncAllOsTypes, sync_all_os_types);
+  for (UserSelectableOsType type : registered_types) {
+    const char* pref_name = GetPrefNameForOsType(type);
+    DCHECK(pref_name);
+    pref_service_->SetBoolean(pref_name, selected_types.Has(type));
+  }
+  for (SyncPrefObserver& observer : sync_pref_observers_) {
+    observer.OnPreferredDataTypesPrefChange();
+  }
+}
+#endif  // defined(OS_CHROMEOS)
+
 bool SyncPrefs::IsManaged() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return pref_service_->GetBoolean(prefs::kSyncManaged);

components/sync/base/sync_prefs.h

@@ -122,6 +122,16 @@ class SyncPrefs : public CryptoSyncPrefs,
                         UserSelectableTypeSet registered_types,
                         UserSelectableTypeSet selected_types);
 
+#if defined(OS_CHROMEOS)
+  // Chrome OS provides a separate settings UI surface for sync of OS types,
+  // including a separate "Sync All" toggle for OS types.
+  bool IsSyncAllOsTypesEnabled() const;
+  UserSelectableOsTypeSet GetSelectedOsTypes() const;
+  void SetSelectedOsTypes(bool sync_all_os_types,
+                          UserSelectableOsTypeSet registered_types,
+                          UserSelectableOsTypeSet selected_types);
+#endif
+
   // Whether Sync is forced off by enterprise policy. Note that this only covers
   // one out of two types of policy, "browser" policy. The second kind, "cloud"
   // policy, is handled directly in ProfileSyncService.

components/sync/base/sync_prefs_unittest.cc

@@ -15,6 +15,7 @@
 #include "components/prefs/testing_pref_service.h"
 #include "components/sync/base/pref_names.h"
 #include "components/sync/base/user_demographics.h"
+#include "components/sync/base/user_selectable_type.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -134,6 +135,19 @@ TEST_F(SyncPrefsTest, ObservedPrefs) {
   sync_prefs_->RemoveSyncPrefObserver(&mock_sync_pref_observer);
 }
 
+#if defined(OS_CHROMEOS)
+TEST_F(SyncPrefsTest, SetSelectedOsTypesTriggersPreferredDataTypesPrefChange) {
+  StrictMock<MockSyncPrefObserver> mock_sync_pref_observer;
+  EXPECT_CALL(mock_sync_pref_observer, OnPreferredDataTypesPrefChange());
+
+  sync_prefs_->AddSyncPrefObserver(&mock_sync_pref_observer);
+  sync_prefs_->SetSelectedOsTypes(/*sync_all_os_types=*/false,
+                                  UserSelectableOsTypeSet(),
+                                  UserSelectableOsTypeSet());
+  sync_prefs_->RemoveSyncPrefObserver(&mock_sync_pref_observer);
+}
+#endif
+
 TEST_F(SyncPrefsTest, ClearPreferences) {
   EXPECT_FALSE(sync_prefs_->IsFirstSetupComplete());
   EXPECT_EQ(base::Time(), sync_prefs_->GetLastSyncedTime());
@@ -283,6 +297,61 @@ TEST_F(SyncPrefsTest, SelectedTypesNotKeepEverythingSynced) {
   }
 }
 
+#if defined(OS_CHROMEOS)
+TEST_F(SyncPrefsTest, IsSyncAllOsTypesEnabled) {
+  EXPECT_TRUE(sync_prefs_->IsSyncAllOsTypesEnabled());
+
+  sync_prefs_->SetSelectedOsTypes(
+      /*sync_all_os_types=*/false,
+      /*registered_types=*/UserSelectableOsTypeSet::All(),
+      /*selected_types=*/UserSelectableOsTypeSet::All());
+  EXPECT_FALSE(sync_prefs_->IsSyncAllOsTypesEnabled());
+  // Browser pref is not affected.
+  EXPECT_TRUE(sync_prefs_->HasKeepEverythingSynced());
+
+  sync_prefs_->SetSelectedOsTypes(
+      /*sync_all_os_types=*/true,
+      /*registered_types=*/UserSelectableOsTypeSet::All(),
+      /*selected_types=*/UserSelectableOsTypeSet::All());
+  EXPECT_TRUE(sync_prefs_->IsSyncAllOsTypesEnabled());
+}
+
+TEST_F(SyncPrefsTest, GetSelectedOsTypesWithAllOsTypesEnabled) {
+  EXPECT_TRUE(sync_prefs_->IsSyncAllOsTypesEnabled());
+  EXPECT_EQ(UserSelectableOsTypeSet::All(), sync_prefs_->GetSelectedOsTypes());
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    sync_prefs_->SetSelectedOsTypes(
+        /*sync_all_os_types=*/true,
+        /*registered_types=*/UserSelectableOsTypeSet::All(),
+        /*selected_types=*/{type});
+    EXPECT_EQ(UserSelectableOsTypeSet::All(),
+              sync_prefs_->GetSelectedOsTypes());
+  }
+}
+
+TEST_F(SyncPrefsTest, GetSelectedOsTypesNotAllOsTypesSelected) {
+  const UserSelectableTypeSet browser_types = sync_prefs_->GetSelectedTypes();
+
+  sync_prefs_->SetSelectedOsTypes(
+      /*sync_all_os_types=*/false,
+      /*registered_types=*/UserSelectableOsTypeSet::All(),
+      /*selected_types=*/UserSelectableOsTypeSet());
+  EXPECT_EQ(UserSelectableOsTypeSet(), sync_prefs_->GetSelectedOsTypes());
+  // Browser types are not changed.
+  EXPECT_EQ(browser_types, sync_prefs_->GetSelectedTypes());
+
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    sync_prefs_->SetSelectedOsTypes(
+        /*sync_all_os_types=*/false,
+        /*registered_types=*/UserSelectableOsTypeSet::All(),
+        /*selected_types=*/{type});
+    EXPECT_EQ(UserSelectableOsTypeSet{type}, sync_prefs_->GetSelectedOsTypes());
+    // Browser types are not changed.
+    EXPECT_EQ(browser_types, sync_prefs_->GetSelectedTypes());
+  }
+}
+#endif  // defined(OS_CHROMEOS)
+
 // Similar to SyncPrefsTest, but does not create a SyncPrefs instance. This lets
 // individual tests set up the "before" state of the PrefService before
 // SyncPrefs gets created.

components/sync/base/user_selectable_type.cc

@@ -7,6 +7,11 @@
 #include <type_traits>
 
 #include "base/logging.h"
+#include "components/sync/base/model_type.h"
+
+#if defined(OS_CHROMEOS)
+#include "chromeos/constants/chromeos_features.h"
+#endif
 
 namespace syncer {
 
@@ -24,11 +29,16 @@ UserSelectableTypeInfo GetUserSelectableTypeInfo(UserSelectableType type) {
   switch (type) {
     case UserSelectableType::kBookmarks:
       return {"bookmarks", BOOKMARKS, {BOOKMARKS}};
-    case UserSelectableType::kPreferences:
-      return {"preferences",
-              PREFERENCES,
-              {PREFERENCES, DICTIONARY, PRIORITY_PREFERENCES, SEARCH_ENGINES,
-               PRINTERS}};
+    case UserSelectableType::kPreferences: {
+      ModelTypeSet model_types = {PREFERENCES, DICTIONARY, PRIORITY_PREFERENCES,
+                                  SEARCH_ENGINES};
+#if defined(OS_CHROMEOS)
+      // SplitSettingsSync makes Printers a separate OS setting.
+      if (!chromeos::features::IsSplitSettingsSyncEnabled())
+        model_types.Put(PRINTERS);
+#endif
+      return {"preferences", PREFERENCES, model_types};
+    }
     case UserSelectableType::kPasswords:
       return {"passwords", PASSWORDS, {PASSWORDS}};
     case UserSelectableType::kAutofill:
@@ -64,6 +74,21 @@ UserSelectableTypeInfo GetUserSelectableTypeInfo(UserSelectableType type) {
   return {nullptr, UNSPECIFIED};
 }
 
+#if defined(OS_CHROMEOS)
+UserSelectableTypeInfo GetUserSelectableOsTypeInfo(UserSelectableOsType type) {
+  // UserSelectableTypeInfo::type_name is used in js code and shouldn't be
+  // changed without updating js part.
+  switch (type) {
+    case UserSelectableOsType::kOsPreferences:
+      return {"osPreferences",
+              OS_PREFERENCES,
+              {OS_PREFERENCES, OS_PRIORITY_PREFERENCES}};
+    case UserSelectableOsType::kPrinters:
+      return {"printers", PRINTERS, {PRINTERS}};
+  }
+}
+#endif
+
 }  // namespace
 
 const char* GetUserSelectableTypeName(UserSelectableType type) {
@@ -85,4 +110,18 @@ int UserSelectableTypeToHistogramInt(UserSelectableType type) {
       ModelTypeHistogramValue(UserSelectableTypeToCanonicalModelType(type)));
 }
 
+#if defined(OS_CHROMEOS)
+const char* GetUserSelectableOsTypeName(UserSelectableOsType type) {
+  return GetUserSelectableOsTypeInfo(type).type_name;
+}
+
+ModelTypeSet UserSelectableOsTypeToAllModelTypes(UserSelectableOsType type) {
+  return GetUserSelectableOsTypeInfo(type).model_type_group;
+}
+
+ModelType UserSelectableOsTypeToCanonicalModelType(UserSelectableOsType type) {
+  return GetUserSelectableOsTypeInfo(type).canonical_model_type;
+}
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace syncer

components/sync/base/user_selectable_type.h

@@ -46,6 +46,25 @@ constexpr int UserSelectableTypeHistogramNumEntries() {
   return static_cast<int>(ModelType::NUM_ENTRIES);
 }
 
+#if defined(OS_CHROMEOS)
+// Chrome OS provides a separate UI with sync controls for OS data types.
+enum class UserSelectableOsType {
+  kOsPreferences,
+  kFirstType = kOsPreferences,
+
+  kPrinters,
+  kLastType = kPrinters
+};
+
+using UserSelectableOsTypeSet = EnumSet<UserSelectableOsType,
+                                        UserSelectableOsType::kFirstType,
+                                        UserSelectableOsType::kLastType>;
+
+const char* GetUserSelectableOsTypeName(UserSelectableOsType type);
+ModelTypeSet UserSelectableOsTypeToAllModelTypes(UserSelectableOsType type);
+ModelType UserSelectableOsTypeToCanonicalModelType(UserSelectableOsType type);
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_BASE_USER_SELECTABLE_TYPE_H_

components/sync/driver/sync_user_settings.h

@@ -72,6 +72,16 @@ class SyncUserSettings {
   // not guaranteed to be registered.
   virtual UserSelectableTypeSet GetForcedTypes() const = 0;
 
+#if defined(OS_CHROMEOS)
+  // As above, but for Chrome OS-specific data types. These are controlled by
+  // toggles in the OS Settings UI.
+  virtual bool IsSyncAllOsTypesEnabled() const = 0;
+  virtual UserSelectableOsTypeSet GetSelectedOsTypes() const = 0;
+  virtual void SetSelectedOsTypes(bool sync_all_os_types,
+                                  UserSelectableOsTypeSet types) = 0;
+  virtual UserSelectableOsTypeSet GetRegisteredSelectableOsTypes() const = 0;
+#endif  // defined(OS_CHROMEOS)
+
   // Encryption state.
   // Note that all of this state may only be queried or modified if the Sync
   // engine is initialized.

components/sync/driver/sync_user_settings_impl.cc

@@ -20,6 +20,16 @@ ModelTypeSet ResolvePreferredTypes(UserSelectableTypeSet selected_types) {
   return preferred_types;
 }
 
+#if defined(OS_CHROMEOS)
+ModelTypeSet ResolvePreferredOsTypes(UserSelectableOsTypeSet selected_types) {
+  ModelTypeSet preferred_types;
+  for (UserSelectableOsType type : selected_types) {
+    preferred_types.PutAll(UserSelectableOsTypeToAllModelTypes(type));
+  }
+  return preferred_types;
+}
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace
 
 SyncUserSettingsImpl::SyncUserSettingsImpl(
@@ -103,6 +113,37 @@ UserSelectableTypeSet SyncUserSettingsImpl::GetRegisteredSelectableTypes()
   return registered_types;
 }
 
+#if defined(OS_CHROMEOS)
+bool SyncUserSettingsImpl::IsSyncAllOsTypesEnabled() const {
+  return prefs_->IsSyncAllOsTypesEnabled();
+}
+
+UserSelectableOsTypeSet SyncUserSettingsImpl::GetSelectedOsTypes() const {
+  UserSelectableOsTypeSet types = prefs_->GetSelectedOsTypes();
+  types.RetainAll(GetRegisteredSelectableOsTypes());
+  return types;
+}
+
+void SyncUserSettingsImpl::SetSelectedOsTypes(bool sync_all_os_types,
+                                              UserSelectableOsTypeSet types) {
+  UserSelectableOsTypeSet registered_types = GetRegisteredSelectableOsTypes();
+  DCHECK(registered_types.HasAll(types));
+  prefs_->SetSelectedOsTypes(sync_all_os_types, registered_types, types);
+}
+
+UserSelectableOsTypeSet SyncUserSettingsImpl::GetRegisteredSelectableOsTypes()
+    const {
+  UserSelectableOsTypeSet registered_types;
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    if (registered_model_types_.Has(
+            UserSelectableOsTypeToCanonicalModelType(type))) {
+      registered_types.Put(type);
+    }
+  }
+  return registered_types;
+}
+#endif  // defined(OS_CHROMEOS)
+
 UserSelectableTypeSet SyncUserSettingsImpl::GetForcedTypes() const {
   if (preference_provider_) {
     return preference_provider_->GetForcedTypes();
@@ -183,7 +224,12 @@ void SyncUserSettingsImpl::SetSyncRequestedIfNotSetExplicitly() {
 
 ModelTypeSet SyncUserSettingsImpl::GetPreferredDataTypes() const {
   ModelTypeSet types;
-  if (IsSyncEverythingEnabled()) {
+#if defined(OS_CHROMEOS)
+  bool sync_everything = IsSyncAllOsTypesEnabled() && IsSyncEverythingEnabled();
+#else
+  bool sync_everything = IsSyncEverythingEnabled();
+#endif
+  if (sync_everything) {
     // TODO(crbug.com/950874): it's possible to remove this case if we accept
     // behavioral change. When one of UserSelectableTypes() isn't registered,
     // but one of its corresponding UserTypes() is registered, current
@@ -194,6 +240,9 @@ ModelTypeSet SyncUserSettingsImpl::GetPreferredDataTypes() const {
   } else {
     types = ResolvePreferredTypes(GetSelectedTypes());
     types.PutAll(AlwaysPreferredUserTypes());
+#if defined(OS_CHROMEOS)
+    types.PutAll(ResolvePreferredOsTypes(GetSelectedOsTypes()));
+#endif
     types.RetainAll(registered_model_types_);
   }
 

components/sync/driver/sync_user_settings_impl.h

@@ -48,6 +48,14 @@ class SyncUserSettingsImpl : public SyncUserSettings {
   UserSelectableTypeSet GetRegisteredSelectableTypes() const override;
   UserSelectableTypeSet GetForcedTypes() const override;
 
+#if defined(OS_CHROMEOS)
+  bool IsSyncAllOsTypesEnabled() const override;
+  UserSelectableOsTypeSet GetSelectedOsTypes() const override;
+  void SetSelectedOsTypes(bool sync_all_os_types,
+                          UserSelectableOsTypeSet types) override;
+  UserSelectableOsTypeSet GetRegisteredSelectableOsTypes() const override;
+#endif
+
   bool IsEncryptEverythingAllowed() const override;
   bool IsEncryptEverythingEnabled() const override;
   void EnableEncryptEverything() override;

components/sync/driver/sync_user_settings_mock.h

@@ -33,6 +33,13 @@ class SyncUserSettingsMock : public SyncUserSettings {
   MOCK_CONST_METHOD0(GetRegisteredSelectableTypes, UserSelectableTypeSet());
   MOCK_CONST_METHOD0(GetForcedTypes, UserSelectableTypeSet());
 
+#if defined(OS_CHROMEOS)
+  MOCK_CONST_METHOD0(IsSyncAllOsTypesEnabled, bool());
+  MOCK_CONST_METHOD0(GetSelectedOsTypes, UserSelectableOsTypeSet());
+  MOCK_METHOD2(SetSelectedOsTypes, void(bool, UserSelectableOsTypeSet));
+  MOCK_CONST_METHOD0(GetRegisteredSelectableOsTypes, UserSelectableOsTypeSet());
+#endif
+
   MOCK_CONST_METHOD0(IsEncryptEverythingAllowed, bool());
   MOCK_CONST_METHOD0(IsEncryptEverythingEnabled, bool());
   MOCK_METHOD0(EnableEncryptEverything, void());

components/sync/driver/sync_user_settings_unittest.cc

@@ -11,6 +11,7 @@
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/pref_names.h"
 #include "components/sync/base/sync_prefs.h"
+#include "components/sync/base/user_selectable_type.h"
 #include "components/sync/driver/sync_service_crypto.h"
 #include "components/sync/engine/configure_reason.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
@@ -117,6 +118,21 @@ TEST_F(SyncUserSettingsTest, PreferredTypesSyncEverything) {
   }
 }
 
+#if defined(OS_CHROMEOS)
+TEST_F(SyncUserSettingsTest, PreferredTypesSyncAllOsTypes) {
+  std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
+      MakeSyncUserSettings(UserTypes());
+
+  EXPECT_TRUE(sync_user_settings->IsSyncAllOsTypesEnabled());
+  EXPECT_EQ(UserTypes(), GetPreferredUserTypes(*sync_user_settings));
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    sync_user_settings->SetSelectedOsTypes(/*sync_all_os_types=*/true,
+                                           /*selected_types=*/{type});
+    EXPECT_EQ(UserTypes(), GetPreferredUserTypes(*sync_user_settings));
+  }
+}
+#endif  // defined(OS_CHROMEOS)
+
 TEST_F(SyncUserSettingsTest, PreferredTypesNotKeepEverythingSynced) {
   std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
       MakeSyncUserSettings(UserTypes());
@@ -124,44 +140,16 @@ TEST_F(SyncUserSettingsTest, PreferredTypesNotKeepEverythingSynced) {
   sync_user_settings->SetSelectedTypes(
       /*sync_everything=*/false,
       /*selected_types=*/UserSelectableTypeSet());
+#if defined(OS_CHROMEOS)
+  sync_user_settings->SetSelectedOsTypes(
+      /*sync_all_os_types=*/false,
+      /*selected_types=*/UserSelectableOsTypeSet());
+#endif
   ASSERT_NE(UserTypes(), GetPreferredUserTypes(*sync_user_settings));
-  for (UserSelectableType type : UserSelectableTypeSet::All()) {
-    ModelTypeSet expected_preferred_types{
-        UserSelectableTypeToCanonicalModelType(type)};
-    if (type == UserSelectableType::kAutofill) {
-      expected_preferred_types.Put(AUTOFILL_PROFILE);
-      expected_preferred_types.Put(AUTOFILL_WALLET_DATA);
-      expected_preferred_types.Put(AUTOFILL_WALLET_METADATA);
-    }
-    if (type == UserSelectableType::kPreferences) {
-      expected_preferred_types.Put(DICTIONARY);
-      expected_preferred_types.Put(PRIORITY_PREFERENCES);
-      expected_preferred_types.Put(SEARCH_ENGINES);
-      expected_preferred_types.Put(PRINTERS);
-    }
-    if (type == UserSelectableType::kApps) {
-      expected_preferred_types.Put(APP_LIST);
-      expected_preferred_types.Put(APP_SETTINGS);
-      expected_preferred_types.Put(ARC_PACKAGE);
-      expected_preferred_types.Put(WEB_APPS);
-    }
-    if (type == UserSelectableType::kExtensions) {
-      expected_preferred_types.Put(EXTENSION_SETTINGS);
-    }
-    if (type == UserSelectableType::kHistory) {
-      expected_preferred_types.Put(HISTORY_DELETE_DIRECTIVES);
-      expected_preferred_types.Put(SESSIONS);
-      expected_preferred_types.Put(FAVICON_IMAGES);
-      expected_preferred_types.Put(FAVICON_TRACKING);
-      expected_preferred_types.Put(USER_EVENTS);
-    }
-    if (type == UserSelectableType::kTabs) {
-      expected_preferred_types.Put(SESSIONS);
-      expected_preferred_types.Put(FAVICON_IMAGES);
-      expected_preferred_types.Put(FAVICON_TRACKING);
-      expected_preferred_types.Put(SEND_TAB_TO_SELF);
-    }
 
+  for (UserSelectableType type : UserSelectableTypeSet::All()) {
+    ModelTypeSet expected_preferred_types =
+        UserSelectableTypeToAllModelTypes(type);
     expected_preferred_types.PutAll(AlwaysPreferredUserTypes());
     sync_user_settings->SetSelectedTypes(/*sync_everything=*/false,
                                          /*selected_types=*/{type});
@@ -170,6 +158,34 @@ TEST_F(SyncUserSettingsTest, PreferredTypesNotKeepEverythingSynced) {
   }
 }
 
+#if defined(OS_CHROMEOS)
+TEST_F(SyncUserSettingsTest, PreferredTypesNotAllOsTypesSynced) {
+  std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
+      MakeSyncUserSettings(UserTypes());
+
+  sync_user_settings->SetSelectedTypes(
+      /*sync_everything=*/false,
+      /*selected_types=*/UserSelectableTypeSet());
+  sync_user_settings->SetSelectedOsTypes(
+      /*sync_all_os_types=*/false,
+      /*selected_types=*/UserSelectableOsTypeSet());
+  EXPECT_FALSE(sync_user_settings->IsSyncEverythingEnabled());
+  EXPECT_FALSE(sync_user_settings->IsSyncAllOsTypesEnabled());
+  EXPECT_EQ(AlwaysPreferredUserTypes(),
+            GetPreferredUserTypes(*sync_user_settings));
+
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    ModelTypeSet expected_preferred_types =
+        UserSelectableOsTypeToAllModelTypes(type);
+    expected_preferred_types.PutAll(AlwaysPreferredUserTypes());
+    sync_user_settings->SetSelectedOsTypes(/*sync_all_os_types=*/false,
+                                           /*selected_types=*/{type});
+    EXPECT_EQ(expected_preferred_types,
+              GetPreferredUserTypes(*sync_user_settings));
+  }
+}
+#endif  // defined(OS_CHROMEOS)
+
 // Device info should always be enabled.
 TEST_F(SyncUserSettingsTest, DeviceInfo) {
   std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
@@ -210,6 +226,28 @@ TEST_F(SyncUserSettingsTest, UserConsents) {
   EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(USER_CONSENTS));
 }
 
+#if defined(OS_CHROMEOS)
+TEST_F(SyncUserSettingsTest, AlwaysPreferredTypes_ChromeOS) {
+  std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
+      MakeSyncUserSettings(UserTypes());
+
+  // Disable all browser types.
+  sync_user_settings->SetSelectedTypes(
+      /*keep_everything_synced=*/false,
+      /*selected_types=*/UserSelectableTypeSet());
+
+  // Disable all OS types.
+  sync_user_settings->SetSelectedOsTypes(
+      /*sync_all_os_types=*/false,
+      /*selected_types=*/UserSelectableOsTypeSet());
+
+  // Important types are still preferred.
+  ModelTypeSet preferred_types = sync_user_settings->GetPreferredDataTypes();
+  EXPECT_TRUE(preferred_types.Has(DEVICE_INFO));
+  EXPECT_TRUE(preferred_types.Has(USER_CONSENTS));
+}
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace
 
 }  // namespace syncer

components/sync/driver/test_sync_user_settings.cc

@@ -6,6 +6,7 @@
 
 #include "components/sync/base/passphrase_enums.h"
 #include "components/sync/base/sync_prefs.h"
+#include "components/sync/base/user_selectable_type.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync/driver/sync_user_settings_impl.h"
 #include "components/sync/driver/test_sync_service.h"
@@ -95,6 +96,45 @@ UserSelectableTypeSet TestSyncUserSettings::GetForcedTypes() const {
   return {};
 }
 
+#if defined(OS_CHROMEOS)
+bool TestSyncUserSettings::IsSyncAllOsTypesEnabled() const {
+  return sync_all_os_types_enabled_;
+}
+
+UserSelectableOsTypeSet TestSyncUserSettings::GetSelectedOsTypes() const {
+  ModelTypeSet preferred_types = service_->GetPreferredDataTypes();
+  UserSelectableOsTypeSet selected_types;
+  for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+    if (preferred_types.Has(UserSelectableOsTypeToCanonicalModelType(type))) {
+      selected_types.Put(type);
+    }
+  }
+  return selected_types;
+}
+
+void TestSyncUserSettings::SetSelectedOsTypes(bool sync_all_os_types,
+                                              UserSelectableOsTypeSet types) {
+  sync_all_os_types_enabled_ = sync_all_os_types;
+
+  syncer::ModelTypeSet preferred_types;
+  if (sync_all_os_types_enabled_) {
+    for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
+      preferred_types.PutAll(UserSelectableOsTypeToAllModelTypes(type));
+    }
+  } else {
+    for (UserSelectableOsType type : types) {
+      preferred_types.PutAll(UserSelectableOsTypeToAllModelTypes(type));
+    }
+  }
+  service_->SetPreferredDataTypes(preferred_types);
+}
+
+UserSelectableOsTypeSet TestSyncUserSettings::GetRegisteredSelectableOsTypes()
+    const {
+  return UserSelectableOsTypeSet::All();
+}
+#endif
+
 bool TestSyncUserSettings::IsEncryptEverythingAllowed() const {
   return true;
 }

components/sync/driver/test_sync_user_settings.h

@@ -37,6 +37,14 @@ class TestSyncUserSettings : public SyncUserSettings {
   UserSelectableTypeSet GetRegisteredSelectableTypes() const override;
   UserSelectableTypeSet GetForcedTypes() const override;
 
+#if defined(OS_CHROMEOS)
+  bool IsSyncAllOsTypesEnabled() const override;
+  UserSelectableOsTypeSet GetSelectedOsTypes() const override;
+  void SetSelectedOsTypes(bool sync_all_os_types,
+                          UserSelectableOsTypeSet types) override;
+  UserSelectableOsTypeSet GetRegisteredSelectableOsTypes() const override;
+#endif
+
   bool IsEncryptEverythingAllowed() const override;
   bool IsEncryptEverythingEnabled() const override;
   void EnableEncryptEverything() override;
@@ -68,6 +76,9 @@ class TestSyncUserSettings : public SyncUserSettings {
 
   bool first_setup_complete_ = true;
   bool sync_everything_enabled_ = true;
+#if defined(OS_CHROMEOS)
+  bool sync_all_os_types_enabled_ = true;
+#endif
 
   bool passphrase_required_ = false;
   bool passphrase_required_for_preferred_data_types_ = false;