Wire up SharingInfo and Sync Service

- Wire up SharingSyncPreference and LocalDeviceInfoProvider
- Added RefreshLocalDeviceInfo to update SharingInfo in sync

Bug: 991971
Change-Id: Ic03a9d3f276b37eebe1eebd4d3afb52b5d5644ac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1816503Reviewed-by: Marc Treib <treib@chromium.org>
Reviewed-by: Mikel Astiz <mastiz@chromium.org>
Commit-Queue: Alex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#702950}

chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc

@@ -18,16 +18,14 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/device_info_sync_service_factory.h"
 #include "components/sync_device_info/device_info.h"
-#include "components/sync_device_info/device_info_sync_service.h"
-#include "components/sync_device_info/fake_device_info_tracker.h"
+#include "components/sync_device_info/fake_device_info_sync_service.h"
 #include "content/public/test/browser_task_environment.h"
 #include "extensions/common/extension.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using syncer::DeviceInfo;
+using syncer::FakeDeviceInfoSyncService;
 using syncer::FakeDeviceInfoTracker;
-using testing::Return;
 
 namespace extensions {
 
@@ -89,39 +87,16 @@ TEST(SignedInDevicesAPITest, GetSignedInDevices) {
   EXPECT_NE(public_id3, public_id2);
 }
 
-class MockDeviceInfoSyncService : public syncer::DeviceInfoSyncService {
- public:
-  MockDeviceInfoSyncService() = default;
-  ~MockDeviceInfoSyncService() override = default;
-
-  FakeDeviceInfoTracker* fake_tracker() { return &tracker_; }
-
-  // DeviceInfoSyncService implementation.
-  syncer::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider() override {
-    return nullptr;
-  }
-  syncer::DeviceInfoTracker* GetDeviceInfoTracker() override {
-    return &tracker_;
-  }
-  base::WeakPtr<syncer::ModelTypeControllerDelegate> GetControllerDelegate()
-      override {
-    return nullptr;
-  }
-
- private:
-  FakeDeviceInfoTracker tracker_;
-};
-
-std::unique_ptr<KeyedService> CreateMockDeviceInfoSyncService(
+std::unique_ptr<KeyedService> CreateFakeDeviceInfoSyncService(
     content::BrowserContext* context) {
-  return std::make_unique<MockDeviceInfoSyncService>();
+  return std::make_unique<FakeDeviceInfoSyncService>();
 }
 
 class ExtensionSignedInDevicesTest : public ExtensionApiUnittest {
  private:
   TestingProfile::TestingFactories GetTestingFactories() override {
     return {{DeviceInfoSyncServiceFactory::GetInstance(),
-             base::BindRepeating(&CreateMockDeviceInfoSyncService)}};
+             base::BindRepeating(&CreateFakeDeviceInfoSyncService)}};
   }
 };
 
@@ -154,10 +129,9 @@ base::DictionaryValue* GetDictionaryFromList(int index,
 }
 
 TEST_F(ExtensionSignedInDevicesTest, GetAll) {
-  FakeDeviceInfoTracker* device_tracker =
-      static_cast<MockDeviceInfoSyncService*>(
-          DeviceInfoSyncServiceFactory::GetForProfile(profile()))
-          ->fake_tracker();
+  FakeDeviceInfoTracker* device_tracker = static_cast<FakeDeviceInfoTracker*>(
+      DeviceInfoSyncServiceFactory::GetForProfile(profile())
+          ->GetDeviceInfoTracker());
 
   DeviceInfo device_info1(
       base::GenerateGUID(), "abc Device", "XYZ v1", "XYZ SyncAgent v1",

chrome/browser/sharing/click_to_call/click_to_call_ui_controller_unittest.cc

@@ -10,7 +10,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/strings/strcat.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
 #include "chrome/browser/sharing/sharing_constants.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
@@ -42,7 +41,7 @@ const char kReceiverName[] = "test_receiver_name";
 
 class MockSharingDeviceRegistration : public SharingDeviceRegistration {
  public:
-  explicit MockSharingDeviceRegistration()
+  MockSharingDeviceRegistration()
       : SharingDeviceRegistration(/* pref_service_= */ nullptr,
                                   /* sharing_sync_preference_= */ nullptr,
                                   /* instance_id_driver_= */ nullptr,

chrome/browser/sharing/shared_clipboard/shared_clipboard_ui_controller_unittest.cc

@@ -10,7 +10,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/strings/strcat.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
 #include "chrome/browser/sharing/sharing_constants.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
@@ -42,7 +41,7 @@ const char kReceiverName[] = "test_receiver_name";
 
 class MockSharingDeviceRegistration : public SharingDeviceRegistration {
  public:
-  explicit MockSharingDeviceRegistration()
+  MockSharingDeviceRegistration()
       : SharingDeviceRegistration(/* pref_service_= */ nullptr,
                                   /* sharing_sync_preference_= */ nullptr,
                                   /* instance_id_driver_= */ nullptr,

chrome/browser/sharing/sharing_device_registration_unittest.cc

@@ -13,7 +13,6 @@
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "build/build_config.h"
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
 #include "chrome/browser/sharing/shared_clipboard/feature_flags.h"
 #include "chrome/browser/sharing/sharing_constants.h"
 #include "chrome/browser/sharing/sharing_device_registration_result.h"
@@ -24,7 +23,7 @@
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_service_factory.h"
 #include "components/sync_device_info/device_info.h"
-#include "components/sync_device_info/fake_device_info_tracker.h"
+#include "components/sync_device_info/fake_device_info_sync_service.h"
 #include "components/sync_preferences/pref_service_mock_factory.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/browser_task_environment.h"
@@ -121,9 +120,7 @@ class FakeInstanceID : public InstanceID {
 class SharingDeviceRegistrationTest : public testing::Test {
  public:
   SharingDeviceRegistrationTest()
-      : sync_prefs_(&prefs_,
-                    &fake_device_info_tracker_,
-                    &fake_local_device_info_provider_),
+      : sync_prefs_(&prefs_, &fake_device_info_sync_service_),
         vapid_key_manager_(&sync_prefs_),
         sharing_device_registration_(pref_service_.get(),
                                      &sync_prefs_,
@@ -161,7 +158,9 @@ class SharingDeviceRegistrationTest : public testing::Test {
           result_ = r;
           local_sharing_info_ = sync_prefs_.GetLocalSharingInfo();
           synced_sharing_info_ = sync_prefs_.GetSharingInfo(
-              fake_local_device_info_provider_.GetLocalDeviceInfo()->guid());
+              fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+                  ->GetLocalDeviceInfo()
+                  ->guid());
           fcm_registration_ = sync_prefs_.GetFCMRegistration();
           run_loop.Quit();
         }));
@@ -175,7 +174,9 @@ class SharingDeviceRegistrationTest : public testing::Test {
           result_ = r;
           local_sharing_info_ = sync_prefs_.GetLocalSharingInfo();
           synced_sharing_info_ = sync_prefs_.GetSharingInfo(
-              fake_local_device_info_provider_.GetLocalDeviceInfo()->guid());
+              fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+                  ->GetLocalDeviceInfo()
+                  ->guid());
           fcm_registration_ = sync_prefs_.GetFCMRegistration();
           run_loop.Quit();
         }));
@@ -208,8 +209,7 @@ class SharingDeviceRegistrationTest : public testing::Test {
 
   sync_preferences::TestingPrefServiceSyncable prefs_;
   NiceMock<MockInstanceIDDriver> mock_instance_id_driver_;
-  syncer::FakeDeviceInfoTracker fake_device_info_tracker_;
-  FakeLocalDeviceInfoProvider fake_local_device_info_provider_;
+  syncer::FakeDeviceInfoSyncService fake_device_info_sync_service_;
   FakeInstanceID fake_instance_id_;
 
   base::test::ScopedFeatureList scoped_feature_list_;
@@ -245,8 +245,9 @@ TEST_F(SharingDeviceRegistrationTest, IsSharedClipboardSupported_False) {
 TEST_F(SharingDeviceRegistrationTest, RegisterDeviceTest_Success) {
   SetInstanceIDFCMResult(InstanceID::Result::SUCCESS);
   SetInstanceIDFCMToken(kFCMToken);
-  fake_device_info_tracker_.Add(
-      fake_local_device_info_provider_.GetLocalDeviceInfo());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+          ->GetLocalDeviceInfo());
 
   RegisterDeviceSync();
 
@@ -280,8 +281,9 @@ TEST_F(SharingDeviceRegistrationTest, RegisterDeviceTest_Success) {
 TEST_F(SharingDeviceRegistrationTest, RegisterDeviceTest_VapidKeysUnchanged) {
   SetInstanceIDFCMToken(kFCMToken);
   SetInstanceIDFCMResult(InstanceID::Result::SUCCESS);
-  fake_device_info_tracker_.Add(
-      fake_local_device_info_provider_.GetLocalDeviceInfo());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+          ->GetLocalDeviceInfo());
 
   RegisterDeviceSync();
 
@@ -309,8 +311,9 @@ TEST_F(SharingDeviceRegistrationTest, RegisterDeviceTest_VapidKeysUnchanged) {
 
 TEST_F(SharingDeviceRegistrationTest, RegisterDeviceTest_Expired) {
   SetInstanceIDFCMResult(InstanceID::Result::SUCCESS);
-  fake_device_info_tracker_.Add(
-      fake_local_device_info_provider_.GetLocalDeviceInfo());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+          ->GetLocalDeviceInfo());
 
   // First register the device.
   RegisterDeviceSync();
@@ -360,8 +363,9 @@ TEST_F(SharingDeviceRegistrationTest, RegisterDeviceTest_FatalError) {
 
 TEST_F(SharingDeviceRegistrationTest, UnregisterDeviceTest_Success) {
   SetInstanceIDFCMResult(InstanceID::Result::SUCCESS);
-  fake_device_info_tracker_.Add(
-      fake_local_device_info_provider_.GetLocalDeviceInfo());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+          ->GetLocalDeviceInfo());
 
   // First register the device.
   RegisterDeviceSync();

chrome/browser/sharing/sharing_fcm_handler_unittest.cc

@@ -6,13 +6,12 @@
 
 #include <memory>
 
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
 #include "chrome/browser/sharing/sharing_constants.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_message_handler.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
-#include "components/sync_device_info/fake_device_info_tracker.h"
+#include "components/sync_device_info/fake_device_info_sync_service.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -60,7 +59,7 @@ class SharingFCMHandlerTest : public Test {
  protected:
   SharingFCMHandlerTest() {
     sync_prefs_ = std::make_unique<SharingSyncPreference>(
-        &prefs_, &fake_device_info_tracker_, &fake_local_device_info_provider_);
+        &prefs_, &fake_device_info_sync_service_);
     sharing_fcm_handler_ = std::make_unique<SharingFCMHandler>(
         &fake_gcm_driver_, &mock_sharing_fcm_sender_, sync_prefs_.get());
     fake_device_info_ = std::make_unique<syncer::DeviceInfo>(
@@ -91,8 +90,7 @@ class SharingFCMHandlerTest : public Test {
   std::unique_ptr<SharingSyncPreference> sync_prefs_;
 
   sync_preferences::TestingPrefServiceSyncable prefs_;
-  syncer::FakeDeviceInfoTracker fake_device_info_tracker_;
-  FakeLocalDeviceInfoProvider fake_local_device_info_provider_;
+  syncer::FakeDeviceInfoSyncService fake_device_info_sync_service_;
 
   std::unique_ptr<syncer::DeviceInfo> fake_device_info_;
 };
@@ -132,7 +130,8 @@ TEST_F(SharingFCMHandlerTest, AckMessageHandler) {
 
 // Generic test for handling of SharingMessage payload other than AckMessage.
 TEST_F(SharingFCMHandlerTest, PingMessageHandler) {
-  fake_device_info_tracker_.Add(fake_device_info_.get());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_.get());
 
   SharingMessage sharing_message;
   sharing_message.set_sender_guid(kSenderGuid);
@@ -172,7 +171,8 @@ TEST_F(SharingFCMHandlerTest, PingMessageHandler) {
 // Test for handling of SharingMessage payload other than AckMessage for
 // secondary users in Android.
 TEST_F(SharingFCMHandlerTest, PingMessageHandlerSecondaryUser) {
-  fake_device_info_tracker_.Add(fake_device_info_.get());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_.get());
 
   SharingMessage sharing_message;
   sharing_message.set_sender_guid(kSenderGuid);

chrome/browser/sharing/sharing_fcm_sender_unittest.cc

@@ -8,14 +8,12 @@
 
 #include "base/base64.h"
 #include "base/callback_list.h"
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
 #include "chrome/browser/sharing/sharing_constants.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
 #include "chrome/browser/sharing/vapid_key_manager.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
 #include "components/sync_device_info/device_info.h"
-#include "components/sync_device_info/fake_device_info_tracker.h"
-#include "components/sync_device_info/local_device_info_provider.h"
+#include "components/sync_device_info/fake_device_info_sync_service.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "crypto/ec_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -102,22 +100,23 @@ class SharingFCMSenderTest : public Test {
   SharingFCMSenderTest() {
     // TODO: Used fake GCMDriver
     sync_prefs_ = std::make_unique<SharingSyncPreference>(
-        &prefs_, &fake_device_info_tracker_, &local_device_info_provider_);
+        &prefs_, &fake_device_info_sync_service);
     sharing_fcm_sender_ = std::make_unique<SharingFCMSender>(
-        &fake_gcm_driver_, &local_device_info_provider_, sync_prefs_.get(),
-        &vapid_key_manager_);
+        &fake_gcm_driver_,
+        fake_device_info_sync_service.GetLocalDeviceInfoProvider(),
+        sync_prefs_.get(), &vapid_key_manager_);
     SharingSyncPreference::RegisterProfilePrefs(prefs_.registry());
   }
 
+  syncer::FakeDeviceInfoSyncService fake_device_info_sync_service;
+  FakeGCMDriver fake_gcm_driver_;
+
   std::unique_ptr<SharingSyncPreference> sync_prefs_;
   std::unique_ptr<SharingFCMSender> sharing_fcm_sender_;
-  FakeGCMDriver fake_gcm_driver_;
   NiceMock<MockVapidKeyManager> vapid_key_manager_;
-  FakeLocalDeviceInfoProvider local_device_info_provider_;
 
  private:
   sync_preferences::TestingPrefServiceSyncable prefs_;
-  syncer::FakeDeviceInfoTracker fake_device_info_tracker_;
 };
 
 }  // namespace
@@ -166,11 +165,13 @@ TEST_P(SharingFCMSenderResultTest, ResultTest) {
   sync_prefs_->SetFCMRegistration(SharingSyncPreference::FCMRegistration(
       kAuthorizedEntity, base::Time::Now()));
   syncer::DeviceInfo* local_device_info =
-      local_device_info_provider_.GetMutableDeviceInfo();
+      fake_device_info_sync_service.GetLocalDeviceInfoProvider()
+          ->GetMutableDeviceInfo();
   local_device_info->set_sharing_info(syncer::DeviceInfo::SharingInfo(
       kSenderFcmToken, kSenderP256dh, kSenderAuthSecret,
       std::set<sync_pb::SharingSpecificFields::EnabledFeatures>()));
-  local_device_info_provider_.SetReady(GetParam().ready_before_send_message);
+  fake_device_info_sync_service.GetLocalDeviceInfoProvider()->SetReady(
+      GetParam().ready_before_send_message);
   fake_gcm_driver_.set_result(GetParam().web_push_result);
 
   std::unique_ptr<crypto::ECPrivateKey> vapid_key =
@@ -192,7 +193,7 @@ TEST_P(SharingFCMSenderResultTest, ResultTest) {
       base::BindOnce(&SharingFCMSenderTest::OnMessageSent,
                      base::Unretained(this), &result, &message_id));
 
-  local_device_info_provider_.SetReady(true);
+  fake_device_info_sync_service.GetLocalDeviceInfoProvider()->SetReady(true);
 
   EXPECT_EQ(kSharingFCMAppID, fake_gcm_driver_.app_id());
   EXPECT_EQ(kAuthorizedEntity, fake_gcm_driver_.authorized_entity());

chrome/browser/sharing/sharing_service_factory.cc

@@ -69,20 +69,23 @@ KeyedService* SharingServiceFactory::BuildServiceInstanceFor(
   gcm::GCMProfileService* gcm_profile_service =
       gcm::GCMProfileServiceFactory::GetForProfile(profile);
   gcm::GCMDriver* gcm_driver = gcm_profile_service->driver();
+
   instance_id::InstanceIDProfileService* instance_id_service =
       instance_id::InstanceIDProfileServiceFactory::GetForProfile(profile);
+
+  syncer::DeviceInfoSyncService* device_info_sync_service =
+      DeviceInfoSyncServiceFactory::GetForProfile(profile);
   syncer::DeviceInfoTracker* device_info_tracker =
-      DeviceInfoSyncServiceFactory::GetForProfile(profile)
-          ->GetDeviceInfoTracker();
+      device_info_sync_service->GetDeviceInfoTracker();
   syncer::LocalDeviceInfoProvider* local_device_info_provider =
-      DeviceInfoSyncServiceFactory::GetForProfile(profile)
-          ->GetLocalDeviceInfoProvider();
+      device_info_sync_service->GetLocalDeviceInfoProvider();
+
   NotificationDisplayService* notification_display_service =
       NotificationDisplayServiceFactory::GetForProfile(profile);
 
   std::unique_ptr<SharingSyncPreference> sync_prefs =
-      std::make_unique<SharingSyncPreference>(
-          profile->GetPrefs(), device_info_tracker, local_device_info_provider);
+      std::make_unique<SharingSyncPreference>(profile->GetPrefs(),
+                                              device_info_sync_service);
   std::unique_ptr<VapidKeyManager> vapid_key_manager =
       std::make_unique<VapidKeyManager>(sync_prefs.get());
   std::unique_ptr<SharingDeviceRegistration> sharing_device_registration =

chrome/browser/sharing/sharing_sync_preference.cc

@@ -5,12 +5,15 @@
 #include "chrome/browser/sharing/sharing_sync_preference.h"
 
 #include "base/base64.h"
+#include "base/feature_list.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/sharing/features.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "components/sync_device_info/device_info_sync_service.h"
 #include "components/sync_device_info/device_info_tracker.h"
 #include "components/sync_device_info/local_device_info_provider.h"
 #include "components/sync_preferences/pref_service_syncable.h"
@@ -58,14 +61,13 @@ SharingSyncPreference::FCMRegistration::~FCMRegistration() = default;
 
 SharingSyncPreference::SharingSyncPreference(
     PrefService* prefs,
-    syncer::DeviceInfoTracker* device_info_tracker,
-    syncer::LocalDeviceInfoProvider* local_device_info_provider)
-    : prefs_(prefs),
-      device_info_tracker_(device_info_tracker),
-      local_device_info_provider_(local_device_info_provider) {
+    syncer::DeviceInfoSyncService* device_info_sync_service)
+    : prefs_(prefs), device_info_sync_service_(device_info_sync_service) {
   DCHECK(prefs_);
-  DCHECK(device_info_tracker_);
-  DCHECK(local_device_info_provider_);
+  DCHECK(device_info_sync_service_);
+  device_info_tracker_ = device_info_sync_service_->GetDeviceInfoTracker();
+  local_device_info_provider_ =
+      device_info_sync_service_->GetLocalDeviceInfoProvider();
   pref_change_registrar_.Init(prefs);
 }
 
@@ -83,6 +85,15 @@ void SharingSyncPreference::RegisterProfilePrefs(
   registry->RegisterDictionaryPref(prefs::kSharingLocalSharingInfo);
 }
 
+// static
+base::Optional<syncer::DeviceInfo::SharingInfo>
+SharingSyncPreference::GetLocalSharingInfoForSync(PrefService* prefs) {
+  if (!base::FeatureList::IsEnabled(kSharingUseDeviceInfo))
+    return base::nullopt;
+
+  return GetLocalSharingInfo(prefs);
+}
+
 base::Optional<std::vector<uint8_t>> SharingSyncPreference::GetVapidKey()
     const {
   const base::DictionaryValue* vapid_key =
@@ -231,6 +242,9 @@ void SharingSyncPreference::SetLocalSharingInfo(
                                           std::move(base64_auth_secret));
   local_sharing_info_update->SetKey(kSharingInfoEnabledFeatures,
                                     std::move(list_value));
+
+  if (base::FeatureList::IsEnabled(kSharingUseDeviceInfo))
+    device_info_sync_service_->RefreshLocalDeviceInfo();
 }
 
 void SharingSyncPreference::ClearLocalSharingInfo() {
@@ -244,6 +258,11 @@ void SharingSyncPreference::ClearLocalSharingInfo() {
 
   // Update prefs::kSharingLocalSharingInfo to clear local cache.
   prefs_->ClearPref(prefs::kSharingLocalSharingInfo);
+
+  if (base::FeatureList::IsEnabled(kSharingUseDeviceInfo) &&
+      device_info->sharing_info()) {
+    device_info_sync_service_->RefreshLocalDeviceInfo();
+  }
 }
 
 // static

chrome/browser/sharing/sharing_sync_preference.h

@@ -20,6 +20,7 @@
 #include "components/sync_device_info/device_info.h"
 
 namespace syncer {
+class DeviceInfoSyncService;
 class DeviceInfoTracker;
 class LocalDeviceInfoProvider;
 }  // namespace syncer
@@ -51,12 +52,15 @@ class SharingSyncPreference {
 
   SharingSyncPreference(
       PrefService* prefs,
-      syncer::DeviceInfoTracker* device_info_tracker,
-      syncer::LocalDeviceInfoProvider* local_device_info_provider);
+      syncer::DeviceInfoSyncService* device_info_sync_service);
   ~SharingSyncPreference();
 
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
+  // Returns local SharingInfo to be uploaded to sync.
+  static base::Optional<syncer::DeviceInfo::SharingInfo>
+  GetLocalSharingInfoForSync(PrefService* prefs);
+
   // Returns VAPID key from preferences if present, otherwise returns
   // base::nullopt.
   // For more information on vapid keys, please see
@@ -108,6 +112,7 @@ class SharingSyncPreference {
       const base::Value& value);
 
   PrefService* prefs_;
+  syncer::DeviceInfoSyncService* device_info_sync_service_;
   syncer::DeviceInfoTracker* device_info_tracker_;
   syncer::LocalDeviceInfoProvider* local_device_info_provider_;
   PrefChangeRegistrar pref_change_registrar_;

chrome/browser/sharing/sharing_sync_preference_unittest.cc

@@ -7,12 +7,15 @@
 #include <memory>
 
 #include "base/guid.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/time/time.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
+#include "chrome/browser/sharing/features.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "components/sync_device_info/fake_device_info_sync_service.h"
 #include "components/sync_device_info/fake_device_info_tracker.h"
+#include "components/sync_device_info/fake_local_device_info_provider.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -35,9 +38,7 @@ const char kAuthorizedEntity[] = "authorized_entity";
 class SharingSyncPreferenceTest : public testing::Test {
  protected:
   SharingSyncPreferenceTest()
-      : sharing_sync_preference_(&prefs_,
-                                 &fake_device_info_tracker_,
-                                 &fake_local_device_info_provider_) {
+      : sharing_sync_preference_(&prefs_, &fake_device_info_sync_service_) {
     SharingSyncPreference::RegisterProfilePrefs(prefs_.registry());
   }
 
@@ -49,9 +50,9 @@ class SharingSyncPreferenceTest : public testing::Test {
   }
 
   sync_preferences::TestingPrefServiceSyncable prefs_;
-  syncer::FakeDeviceInfoTracker fake_device_info_tracker_;
-  FakeLocalDeviceInfoProvider fake_local_device_info_provider_;
+  syncer::FakeDeviceInfoSyncService fake_device_info_sync_service_;
   SharingSyncPreference sharing_sync_preference_;
+  base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 TEST_F(SharingSyncPreferenceTest, UpdateVapidKeys) {
@@ -61,33 +62,87 @@ TEST_F(SharingSyncPreferenceTest, UpdateVapidKeys) {
 }
 
 TEST_F(SharingSyncPreferenceTest, SyncAndRemoveLocalDevice) {
+  scoped_feature_list_.InitAndEnableFeature(kSharingUseDeviceInfo);
   const syncer::DeviceInfo* local_device_info =
-      fake_local_device_info_provider_.GetLocalDeviceInfo();
-  fake_device_info_tracker_.Add(local_device_info);
+      fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+          ->GetLocalDeviceInfo();
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(local_device_info);
   EXPECT_FALSE(sharing_sync_preference_.GetLocalSharingInfo());
   EXPECT_FALSE(
       sharing_sync_preference_.GetSharingInfo(local_device_info->guid()));
 
+  // Setting SharingInfo should trigger RefreshLocalDeviceInfoCount.
   auto sharing_info = GetDefaultSharingInfo();
   sharing_sync_preference_.SetLocalSharingInfo(sharing_info);
 
   EXPECT_EQ(sharing_info, sharing_sync_preference_.GetLocalSharingInfo());
   EXPECT_EQ(sharing_info,
             sharing_sync_preference_.GetSharingInfo(local_device_info->guid()));
+  EXPECT_EQ(1, fake_device_info_sync_service_.RefreshLocalDeviceInfoCount());
 
+  // Assume LocalDeviceInfoProvider is updated now.
+  fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+      ->GetMutableDeviceInfo()
+      ->set_sharing_info(sharing_info);
+
+  // Setting exactly the same SharingInfo in LocalDeviceInfoProvider shouldn't
+  // trigger RefreshLocalDeviceInfoCount.
+  sharing_sync_preference_.SetLocalSharingInfo(sharing_info);
+
+  EXPECT_EQ(sharing_info, sharing_sync_preference_.GetLocalSharingInfo());
+  EXPECT_EQ(sharing_info,
+            sharing_sync_preference_.GetSharingInfo(local_device_info->guid()));
+  EXPECT_EQ(1, fake_device_info_sync_service_.RefreshLocalDeviceInfoCount());
+
+  // Clearing SharingInfo should trigger RefreshLocalDeviceInfoCount.
   sharing_sync_preference_.ClearLocalSharingInfo();
 
+  // Assume LocalDeviceInfoProvider has SharingInfo cleared.
+  fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+      ->GetMutableDeviceInfo()
+      ->set_sharing_info(base::nullopt);
+
   EXPECT_FALSE(sharing_sync_preference_.GetLocalSharingInfo());
   EXPECT_FALSE(
       sharing_sync_preference_.GetSharingInfo(local_device_info->guid()));
+  EXPECT_EQ(2, fake_device_info_sync_service_.RefreshLocalDeviceInfoCount());
+}
+
+TEST_F(SharingSyncPreferenceTest,
+       SyncAndRemoveLocalDevice_UseDeviceInfoDisabled) {
+  scoped_feature_list_.InitAndDisableFeature(kSharingUseDeviceInfo);
+
+  auto sharing_info = GetDefaultSharingInfo();
+  sharing_sync_preference_.SetLocalSharingInfo(sharing_info);
+
+  // Sharing info is set but RefreshLocalDeviceInfoCount is not triggered.
+  EXPECT_EQ(sharing_info, sharing_sync_preference_.GetLocalSharingInfo());
+  EXPECT_EQ(0, fake_device_info_sync_service_.RefreshLocalDeviceInfoCount());
+
+  // Assume LocalDeviceInfoProvider is updated now.
+  fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+      ->GetMutableDeviceInfo()
+      ->set_sharing_info(sharing_info);
+
+  sharing_sync_preference_.ClearLocalSharingInfo();
+
+  // Assume LocalDeviceInfoProvider has SharingInfo cleared.
+  fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+      ->GetMutableDeviceInfo()
+      ->set_sharing_info(base::nullopt);
+
+  // Sharing info is cleared but RefreshLocalDeviceInfoCount is not triggered.
+  EXPECT_FALSE(sharing_sync_preference_.GetLocalSharingInfo());
+  EXPECT_EQ(0, fake_device_info_sync_service_.RefreshLocalDeviceInfoCount());
 }
 
 TEST_F(SharingSyncPreferenceTest, GetLocalSharingInfoFromProvider) {
   EXPECT_FALSE(sharing_sync_preference_.GetLocalSharingInfo());
 
   auto sharing_info = GetDefaultSharingInfo();
-  fake_local_device_info_provider_.GetMutableDeviceInfo()->set_sharing_info(
-      sharing_info);
+  fake_device_info_sync_service_.GetLocalDeviceInfoProvider()
+      ->GetMutableDeviceInfo()
+      ->set_sharing_info(sharing_info);
 
   EXPECT_EQ(sharing_info, sharing_sync_preference_.GetLocalSharingInfo());
 }
@@ -100,7 +155,8 @@ TEST_F(SharingSyncPreferenceTest, GetSharingInfoFromProvider) {
           /*last_updated_timestamp=*/base::Time::Now(),
           /*send_tab_to_self_receiving_enabled=*/false,
           /*sharing_info=*/base::nullopt);
-  fake_device_info_tracker_.Add(fake_device_info_.get());
+  fake_device_info_sync_service_.GetDeviceInfoTracker()->Add(
+      fake_device_info_.get());
   EXPECT_FALSE(sharing_sync_preference_.GetSharingInfo(kDeviceGuid));
 
   auto sharing_info = GetDefaultSharingInfo();
@@ -124,3 +180,23 @@ TEST_F(SharingSyncPreferenceTest, FCMRegistrationGetSet) {
   sharing_sync_preference_.ClearFCMRegistration();
   EXPECT_FALSE(sharing_sync_preference_.GetFCMRegistration());
 }
+
+TEST_F(SharingSyncPreferenceTest, GetLocalSharingInfoForSync) {
+  scoped_feature_list_.InitAndEnableFeature(kSharingUseDeviceInfo);
+
+  auto sharing_info = GetDefaultSharingInfo();
+  sharing_sync_preference_.SetLocalSharingInfo(sharing_info);
+
+  EXPECT_EQ(sharing_info,
+            SharingSyncPreference::GetLocalSharingInfoForSync(&prefs_));
+}
+
+TEST_F(SharingSyncPreferenceTest,
+       GetLocalSharingInfoForSync_UseDeviceInfoDisabled) {
+  scoped_feature_list_.InitAndDisableFeature(kSharingUseDeviceInfo);
+
+  auto sharing_info = GetDefaultSharingInfo();
+  sharing_sync_preference_.SetLocalSharingInfo(sharing_info);
+
+  EXPECT_FALSE(SharingSyncPreference::GetLocalSharingInfoForSync(&prefs_));
+}

chrome/browser/sharing/vapid_key_manager_unittest.cc

@@ -4,9 +4,8 @@
 
 #include "chrome/browser/sharing/vapid_key_manager.h"
 
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
-#include "components/sync_device_info/fake_device_info_tracker.h"
+#include "components/sync_device_info/fake_device_info_sync_service.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "crypto/ec_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -17,17 +16,14 @@ namespace {
 class VapidKeyManagerTest : public testing::Test {
  protected:
   VapidKeyManagerTest()
-      : sharing_sync_preference_(&prefs_,
-                                 &fake_device_info_tracker_,
-                                 &fake_local_device_info_provider_),
+      : sharing_sync_preference_(&prefs_, &fake_device_info_sync_service_),
         vapid_key_manager_(&sharing_sync_preference_) {
     SharingSyncPreference::RegisterProfilePrefs(prefs_.registry());
   }
 
-  SharingSyncPreference sharing_sync_preference_;
   sync_preferences::TestingPrefServiceSyncable prefs_;
-  syncer::FakeDeviceInfoTracker fake_device_info_tracker_;
-  FakeLocalDeviceInfoProvider fake_local_device_info_provider_;
+  syncer::FakeDeviceInfoSyncService fake_device_info_sync_service_;
+  SharingSyncPreference sharing_sync_preference_;
   VapidKeyManager vapid_key_manager_;
 };
 

chrome/browser/sync/device_info_sync_service_factory.cc

@@ -16,6 +16,7 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/sharing/sharing_sync_preference.h"
 #include "chrome/browser/signin/chrome_device_id_helper.h"
 #include "chrome/browser/sync/model_type_store_service_factory.h"
 #include "chrome/common/channel_info.h"
@@ -58,8 +59,8 @@ class DeviceInfoSyncClient : public syncer::DeviceInfoSyncClient {
   // syncer::DeviceInfoSyncClient:
   base::Optional<syncer::DeviceInfo::SharingInfo> GetLocalSharingInfo()
       const override {
-    // TODO(crbug.com/991971): Returns from SharingSyncPreference.
-    return base::nullopt;
+    return SharingSyncPreference::GetLocalSharingInfoForSync(
+        profile_->GetPrefs());
   }
 
  private:

chrome/test/BUILD.gn

@@ -3225,8 +3225,6 @@ test("unit_tests") {
     "../browser/sessions/restore_on_startup_policy_handler_unittest.cc",
     "../browser/sessions/session_common_utils_unittest.cc",
     "../browser/sharing/ack_message_handler_unittest.cc",
-    "../browser/sharing/fake_local_device_info_provider.cc",
-    "../browser/sharing/fake_local_device_info_provider.h",
     "../browser/sharing/sharing_device_registration_unittest.cc",
     "../browser/sharing/sharing_fcm_handler_unittest.cc",
     "../browser/sharing/sharing_fcm_sender_unittest.cc",

components/sync_device_info/BUILD.gn

@@ -69,13 +69,21 @@ jumbo_static_library("sync_device_info") {
 static_library("test_support") {
   testonly = true
   sources = [
+    "fake_device_info_sync_service.cc",
+    "fake_device_info_sync_service.h",
     "fake_device_info_tracker.cc",
     "fake_device_info_tracker.h",
+    "fake_local_device_info_provider.cc",
+    "fake_local_device_info_provider.h",
   ]
 
   public_deps = [
     ":sync_device_info",
   ]
+
+  deps = [
+    "//components/sync:test_support_model",
+  ]
 }
 
 source_set("unit_tests") {

components/sync_device_info/device_info_sync_bridge.cc

@@ -183,6 +183,10 @@ LocalDeviceInfoProvider* DeviceInfoSyncBridge::GetLocalDeviceInfoProvider() {
   return local_device_info_provider_.get();
 }
 
+void DeviceInfoSyncBridge::RefreshLocalDeviceInfo() {
+  SendLocalData();
+}
+
 void DeviceInfoSyncBridge::OnSyncStarting(
     const DataTypeActivationRequest& request) {
   // Store the cache GUID, mainly in case MergeSyncData() is executed later.

components/sync_device_info/device_info_sync_bridge.h

@@ -46,6 +46,12 @@ class DeviceInfoSyncBridge : public ModelTypeSyncBridge,
 
   LocalDeviceInfoProvider* GetLocalDeviceInfoProvider();
 
+  // Refresh local copy of device info in memory, and informs sync of the
+  // change. Used when the caller knows a property of local device info has
+  // changed (e.g. SharingInfo), and must be sync-ed to other devices as soon as
+  // possible, without waiting for the periodic commits.
+  void RefreshLocalDeviceInfo();
+
   // ModelTypeSyncBridge implementation.
   void OnSyncStarting(const DataTypeActivationRequest& request) override;
   std::unique_ptr<MetadataChangeList> CreateMetadataChangeList() override;

components/sync_device_info/device_info_sync_bridge_unittest.cc

@@ -359,6 +359,8 @@ class DeviceInfoSyncBridgeTest : public testing::Test,
 
   void ForcePulse() { bridge()->ForcePulseForTest(); }
 
+  void RefreshLocalDeviceInfo() { bridge()->RefreshLocalDeviceInfo(); }
+
   void CommitToStoreAndWait(std::unique_ptr<WriteBatch> batch) {
     base::RunLoop loop;
     store()->CommitWriteBatch(
@@ -1035,6 +1037,19 @@ TEST_F(DeviceInfoSyncBridgeTest, ExpireOldEntriesUponStartup) {
                   Pair(specifics_fresh.cache_guid(), _)));
 }
 
+TEST_F(DeviceInfoSyncBridgeTest, RefreshLocalDeviceInfo) {
+  // Ensure |last_updated| is about now, plus or minus a little bit.
+  EXPECT_CALL(*processor(), Put(_, HasSpecifics(HasLastUpdatedAboutNow()), _));
+  InitializeAndMergeInitialData();
+  EXPECT_EQ(1, change_count());
+  testing::Mock::VerifyAndClearExpectations(processor());
+
+  // Ensure |last_updated| is about now, plus or minus a little bit.
+  EXPECT_CALL(*processor(), Put(_, HasSpecifics(HasLastUpdatedAboutNow()), _));
+  RefreshLocalDeviceInfo();
+  EXPECT_EQ(2, change_count());
+}
+
 }  // namespace
 
 }  // namespace syncer

components/sync_device_info/device_info_sync_service.h

@@ -33,6 +33,12 @@ class DeviceInfoSyncService : public KeyedService {
   // Returns the ModelTypeControllerDelegate for DEVICE_INFO.
   virtual base::WeakPtr<ModelTypeControllerDelegate>
   GetControllerDelegate() = 0;
+
+  // Interface to refresh local copy of device info in memory, and informs sync
+  // of the change. Used when the caller knows a property of local device info
+  // has changed (e.g. SharingInfo), and must be sync-ed to other devices as
+  // soon as possible, without waiting for the periodic commits.
+  virtual void RefreshLocalDeviceInfo() = 0;
 };
 
 }  // namespace syncer

components/sync_device_info/device_info_sync_service_impl.cc

@@ -58,4 +58,8 @@ DeviceInfoSyncServiceImpl::GetControllerDelegate() {
   return bridge_->change_processor()->GetControllerDelegate();
 }
 
+void DeviceInfoSyncServiceImpl::RefreshLocalDeviceInfo() {
+  bridge_->RefreshLocalDeviceInfo();
+}
+
 }  // namespace syncer

components/sync_device_info/device_info_sync_service_impl.h

@@ -35,6 +35,7 @@ class DeviceInfoSyncServiceImpl : public DeviceInfoSyncService {
   LocalDeviceInfoProvider* GetLocalDeviceInfoProvider() override;
   DeviceInfoTracker* GetDeviceInfoTracker() override;
   base::WeakPtr<ModelTypeControllerDelegate> GetControllerDelegate() override;
+  void RefreshLocalDeviceInfo() override;
 
  private:
   std::unique_ptr<DeviceInfoSyncClient> device_info_sync_client_;

components/sync_device_info/fake_device_info_sync_service.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 "components/sync_device_info/fake_device_info_sync_service.h"
+
+namespace syncer {
+
+FakeDeviceInfoSyncService::FakeDeviceInfoSyncService()
+    : fake_model_type_controller_delegate_(ModelType::DEVICE_INFO) {}
+
+FakeDeviceInfoSyncService::~FakeDeviceInfoSyncService() = default;
+
+FakeLocalDeviceInfoProvider*
+FakeDeviceInfoSyncService::GetLocalDeviceInfoProvider() {
+  return &fake_local_device_info_provider_;
+}
+
+FakeDeviceInfoTracker* FakeDeviceInfoSyncService::GetDeviceInfoTracker() {
+  return &fake_device_info_tracker_;
+}
+
+base::WeakPtr<ModelTypeControllerDelegate>
+FakeDeviceInfoSyncService::GetControllerDelegate() {
+  return fake_model_type_controller_delegate_.GetWeakPtr();
+}
+
+void FakeDeviceInfoSyncService::RefreshLocalDeviceInfo() {
+  refresh_local_device_info_count_++;
+}
+
+int FakeDeviceInfoSyncService::RefreshLocalDeviceInfoCount() {
+  return refresh_local_device_info_count_;
+}
+
+}  // namespace syncer

components/sync_device_info/fake_device_info_sync_service.h

+// 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.
+
+#ifndef COMPONENTS_SYNC_DEVICE_INFO_FAKE_DEVICE_INFO_SYNC_SERVICE_H_
+#define COMPONENTS_SYNC_DEVICE_INFO_FAKE_DEVICE_INFO_SYNC_SERVICE_H_
+
+#include "components/sync/model/fake_model_type_controller_delegate.h"
+#include "components/sync_device_info/device_info_sync_service.h"
+#include "components/sync_device_info/fake_device_info_tracker.h"
+#include "components/sync_device_info/fake_local_device_info_provider.h"
+
+namespace syncer {
+
+class FakeDeviceInfoSyncService : public DeviceInfoSyncService {
+ public:
+  FakeDeviceInfoSyncService();
+  ~FakeDeviceInfoSyncService() override;
+
+  // DeviceInfoSyncService implementation.
+  FakeLocalDeviceInfoProvider* GetLocalDeviceInfoProvider() override;
+  FakeDeviceInfoTracker* GetDeviceInfoTracker() override;
+  base::WeakPtr<ModelTypeControllerDelegate> GetControllerDelegate() override;
+  void RefreshLocalDeviceInfo() override;
+
+  // Returns number of times RefreshLocalDeviceInfo() has neen called.
+  int RefreshLocalDeviceInfoCount();
+
+ private:
+  FakeDeviceInfoTracker fake_device_info_tracker_;
+  FakeLocalDeviceInfoProvider fake_local_device_info_provider_;
+  FakeModelTypeControllerDelegate fake_model_type_controller_delegate_;
+
+  int refresh_local_device_info_count_ = 0;
+};
+
+}  // namespace syncer
+
+#endif  // COMPONENTS_SYNC_DEVICE_INFO_FAKE_DEVICE_INFO_SYNC_SERVICE_H_

chrome/browser/sharing/fake_local_device_info_provider.cc → components/sync_device_info/fake_local_device_info_provider.cc

@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/sharing/fake_local_device_info_provider.h"
+#include "components/sync_device_info/fake_local_device_info_provider.h"
 
 #include "base/time/time.h"
 
+namespace syncer {
+
 FakeLocalDeviceInfoProvider::FakeLocalDeviceInfoProvider()
     : device_info_("id",
                    "name",
@@ -24,12 +26,11 @@ version_info::Channel FakeLocalDeviceInfoProvider::GetChannel() const {
   return version_info::Channel::UNKNOWN;
 }
 
-const syncer::DeviceInfo* FakeLocalDeviceInfoProvider::GetLocalDeviceInfo()
-    const {
+const DeviceInfo* FakeLocalDeviceInfoProvider::GetLocalDeviceInfo() const {
   return ready_ ? &device_info_ : nullptr;
 }
 
-std::unique_ptr<syncer::LocalDeviceInfoProvider::Subscription>
+std::unique_ptr<LocalDeviceInfoProvider::Subscription>
 FakeLocalDeviceInfoProvider::RegisterOnInitializedCallback(
     const base::RepeatingClosure& callback) {
   return callback_list_.Add(callback);
@@ -42,6 +43,8 @@ void FakeLocalDeviceInfoProvider::SetReady(bool ready) {
     callback_list_.Notify();
 }
 
-syncer::DeviceInfo* FakeLocalDeviceInfoProvider::GetMutableDeviceInfo() {
+DeviceInfo* FakeLocalDeviceInfoProvider::GetMutableDeviceInfo() {
   return &device_info_;
 }
+
+}  // namespace syncer

chrome/browser/sharing/fake_local_device_info_provider.h → components/sync_device_info/fake_local_device_info_provider.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_SHARING_FAKE_LOCAL_DEVICE_INFO_PROVIDER_H_
-#define CHROME_BROWSER_SHARING_FAKE_LOCAL_DEVICE_INFO_PROVIDER_H_
+#ifndef COMPONENTS_SYNC_DEVICE_INFO_FAKE_LOCAL_DEVICE_INFO_PROVIDER_H_
+#define COMPONENTS_SYNC_DEVICE_INFO_FAKE_LOCAL_DEVICE_INFO_PROVIDER_H_
 
 #include <memory>
 
@@ -11,26 +11,30 @@
 #include "components/sync_device_info/device_info.h"
 #include "components/sync_device_info/local_device_info_provider.h"
 
-class FakeLocalDeviceInfoProvider : public syncer::LocalDeviceInfoProvider {
+namespace syncer {
+
+class FakeLocalDeviceInfoProvider : public LocalDeviceInfoProvider {
  public:
   FakeLocalDeviceInfoProvider();
   ~FakeLocalDeviceInfoProvider() override;
 
-  // Overrides for syncer::LocalDeviceInfoProvider.
+  // Overrides for LocalDeviceInfoProvider.
   version_info::Channel GetChannel() const override;
-  const syncer::DeviceInfo* GetLocalDeviceInfo() const override;
+  const DeviceInfo* GetLocalDeviceInfo() const override;
   std::unique_ptr<Subscription> RegisterOnInitializedCallback(
       const base::RepeatingClosure& callback) override;
 
   void SetReady(bool ready);
-  syncer::DeviceInfo* GetMutableDeviceInfo();
+  DeviceInfo* GetMutableDeviceInfo();
 
  private:
-  syncer::DeviceInfo device_info_;
+  DeviceInfo device_info_;
   bool ready_ = true;
   base::CallbackList<void(void)> callback_list_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeLocalDeviceInfoProvider);
 };
 
-#endif  // CHROME_BROWSER_SHARING_FAKE_LOCAL_DEVICE_INFO_PROVIDER_H_
+}  // namespace syncer
+
+#endif  // COMPONENTS_SYNC_DEVICE_INFO_FAKE_LOCAL_DEVICE_INFO_PROVIDER_H_