Extract SharingDeviceSource from SharingService.

This moves the logic for getting a list of devices from SharingService
to a new class. The SharedClipboardMessageHandler can then use the new
class instead of the dependency on SharingService.

Bug: 1021980
Change-Id: Ie1b0146b6aaf60949481ac161bfd69905cf7c803
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1910097
Commit-Queue: Richard Knoll <knollr@chromium.org>
Reviewed-by: Alex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715289}

chrome/browser/BUILD.gn

@@ -1564,6 +1564,10 @@ jumbo_static_library("browser") {
     "sharing/sharing_device_registration.cc",
     "sharing/sharing_device_registration.h",
     "sharing/sharing_device_registration_result.h",
+    "sharing/sharing_device_source.cc",
+    "sharing/sharing_device_source.h",
+    "sharing/sharing_device_source_sync.cc",
+    "sharing/sharing_device_source_sync.h",
     "sharing/sharing_fcm_handler.cc",
     "sharing/sharing_fcm_handler.h",
     "sharing/sharing_fcm_sender.cc",

chrome/browser/sharing/click_to_call/click_to_call_utils_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/test/scoped_feature_list.h"
 #include "chrome/browser/sharing/click_to_call/click_to_call_utils.h"
 #include "chrome/browser/sharing/click_to_call/feature.h"
+#include "chrome/browser/sharing/sharing_device_source.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_service.h"
@@ -96,11 +97,10 @@ class ClickToCallUtilsTest : public testing::Test {
             /*gcm_driver=*/nullptr, /*sharing_fcm_sender=*/nullptr,
             /*sync_preference=nullptr*/ nullptr),
         /*message_sender_=*/nullptr,
-        /* gcm_driver= */ nullptr,
-        /* device_info_tracker= */ nullptr,
-        /* local_device_info_provider= */ nullptr,
-        /* sync_service */ nullptr,
-        /* sms_fetcher= */ nullptr);
+        /*device_source=*/nullptr,
+        /*gcm_driver=*/nullptr,
+        /*sync_service=*/nullptr,
+        /*sms_fetcher=*/nullptr);
   }
 
   base::test::ScopedFeatureList scoped_feature_list_;

chrome/browser/sharing/mock_sharing_service.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 #include "chrome/browser/sharing/mock_sharing_service.h"
 
+#include "chrome/browser/sharing/sharing_device_source.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
@@ -24,9 +25,8 @@ MockSharingService::MockSharingService()
                                               /*sharing_fcm_sender=*/nullptr,
                                               /*sync_preference=*/nullptr),
           /*message_sender=*/nullptr,
+          /*device_source=*/nullptr,
           /*gcm_driver=*/nullptr,
-          /*device_info_tracker=*/nullptr,
-          /*local_device_info_provider=*/nullptr,
           /*sync_service*/ nullptr,
           /*sms_fetcher=*/nullptr) {}
 

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler.cc

@@ -8,7 +8,7 @@
 #include <string>
 
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/sharing/sharing_service.h"
+#include "chrome/browser/sharing/sharing_device_source.h"
 #include "components/sync/protocol/sharing_message.pb.h"
 #include "components/sync/protocol/sharing_shared_clipboard_message.pb.h"
 #include "components/sync_device_info/device_info.h"
@@ -16,8 +16,8 @@
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 
 SharedClipboardMessageHandler::SharedClipboardMessageHandler(
-    SharingService* sharing_service)
-    : sharing_service_(sharing_service) {}
+    SharingDeviceSource* device_source)
+    : device_source_(device_source) {}
 
 SharedClipboardMessageHandler::~SharedClipboardMessageHandler() = default;
 
@@ -30,7 +30,7 @@ void SharedClipboardMessageHandler::OnMessage(
       .WriteText(base::UTF8ToUTF16(message.shared_clipboard_message().text()));
 
   std::unique_ptr<syncer::DeviceInfo> device =
-      sharing_service_->GetDeviceByGuid(message.sender_guid());
+      device_source_->GetDeviceByGuid(message.sender_guid());
   const std::string& device_name =
       device ? device->client_name() : message.sender_device_name();
   ShowNotification(device_name);

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler.h

@@ -10,12 +10,12 @@
 #include "base/macros.h"
 #include "chrome/browser/sharing/sharing_message_handler.h"
 
-class SharingService;
+class SharingDeviceSource;
 
 // Handles incoming messages for the shared clipboard feature.
 class SharedClipboardMessageHandler : public SharingMessageHandler {
  public:
-  explicit SharedClipboardMessageHandler(SharingService* sharing_service);
+  explicit SharedClipboardMessageHandler(SharingDeviceSource* device_source);
   ~SharedClipboardMessageHandler() override;
 
   // SharingMessageHandler implementation:
@@ -28,7 +28,7 @@ class SharedClipboardMessageHandler : public SharingMessageHandler {
   virtual void ShowNotification(const std::string& device_name) = 0;
 
  private:
-  SharingService* sharing_service_ = nullptr;
+  SharingDeviceSource* device_source_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(SharedClipboardMessageHandler);
 };

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler_android.cc

@@ -10,8 +10,8 @@
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 
 SharedClipboardMessageHandlerAndroid::SharedClipboardMessageHandlerAndroid(
-    SharingService* sharing_service)
-    : SharedClipboardMessageHandler(sharing_service) {}
+    SharingDeviceSource* device_source)
+    : SharedClipboardMessageHandler(device_source) {}
 
 SharedClipboardMessageHandlerAndroid::~SharedClipboardMessageHandlerAndroid() =
     default;

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler_android.h

@@ -8,13 +8,13 @@
 #include "base/macros.h"
 #include "chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler.h"
 
-class SharingService;
+class SharingDeviceSource;
 
 class SharedClipboardMessageHandlerAndroid
     : public SharedClipboardMessageHandler {
  public:
   explicit SharedClipboardMessageHandlerAndroid(
-      SharingService* sharing_service);
+      SharingDeviceSource* device_source);
   ~SharedClipboardMessageHandlerAndroid() override;
 
  private:

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler_desktop.cc

@@ -17,9 +17,9 @@
 #include "url/gurl.h"
 
 SharedClipboardMessageHandlerDesktop::SharedClipboardMessageHandlerDesktop(
-    SharingService* sharing_service,
+    SharingDeviceSource* device_source,
     Profile* profile)
-    : SharedClipboardMessageHandler(sharing_service), profile_(profile) {}
+    : SharedClipboardMessageHandler(device_source), profile_(profile) {}
 
 SharedClipboardMessageHandlerDesktop::~SharedClipboardMessageHandlerDesktop() =
     default;

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler_desktop.h

@@ -9,13 +9,13 @@
 #include "chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler.h"
 
 class Profile;
-class SharingService;
+class SharingDeviceSource;
 
 // Handles incoming messages for the shared clipboard feature.
 class SharedClipboardMessageHandlerDesktop
     : public SharedClipboardMessageHandler {
  public:
-  SharedClipboardMessageHandlerDesktop(SharingService* sharing_service,
+  SharedClipboardMessageHandlerDesktop(SharingDeviceSource* device_source,
                                        Profile* profile);
   ~SharedClipboardMessageHandlerDesktop() override;
 

chrome/browser/sharing/shared_clipboard/shared_clipboard_message_handler_desktop_unittest.cc

@@ -9,6 +9,7 @@
 #include "base/test/mock_callback.h"
 #include "chrome/browser/sharing/mock_sharing_service.h"
 #include "chrome/browser/sharing/shared_clipboard/shared_clipboard_test_base.h"
+#include "chrome/browser/sharing/sharing_device_source.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync/protocol/sharing_shared_clipboard_message.pb.h"
@@ -25,6 +26,17 @@ const char kEmptyDeviceName[] = "";
 const char kDeviceNameInDeviceInfo[] = "DeviceNameInDeviceInfo";
 const char kDeviceNameInMessage[] = "DeviceNameInMessage";
 
+class MockSharingDeviceSource : public SharingDeviceSource {
+ public:
+  bool IsReady() override { return true; }
+
+  MOCK_METHOD1(GetDeviceByGuid,
+               std::unique_ptr<syncer::DeviceInfo>(const std::string& guid));
+
+  MOCK_METHOD0(GetAllDevices,
+               std::vector<std::unique_ptr<syncer::DeviceInfo>>());
+};
+
 class SharedClipboardMessageHandlerTest : public SharedClipboardTestBase {
  public:
   SharedClipboardMessageHandlerTest() = default;
@@ -34,7 +46,7 @@ class SharedClipboardMessageHandlerTest : public SharedClipboardTestBase {
   void SetUp() override {
     SharedClipboardTestBase::SetUp();
     message_handler_ = std::make_unique<SharedClipboardMessageHandlerDesktop>(
-        sharing_service_.get(), &profile_);
+        &device_source_, &profile_);
   }
 
   chrome_browser_sharing::SharingMessage CreateMessage(std::string guid,
@@ -48,6 +60,7 @@ class SharedClipboardMessageHandlerTest : public SharedClipboardTestBase {
 
  protected:
   std::unique_ptr<SharedClipboardMessageHandlerDesktop> message_handler_;
+  MockSharingDeviceSource device_source_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedClipboardMessageHandlerTest);
 };
@@ -57,7 +70,7 @@ class SharedClipboardMessageHandlerTest : public SharedClipboardTestBase {
 TEST_F(SharedClipboardMessageHandlerTest, NotificationWithoutDeviceName) {
   std::string guid = base::GenerateGUID();
   {
-    EXPECT_CALL(*sharing_service_, GetDeviceByGuid(guid))
+    EXPECT_CALL(device_source_, GetDeviceByGuid(guid))
         .WillOnce(
             [](const std::string& guid) -> std::unique_ptr<syncer::DeviceInfo> {
               return nullptr;
@@ -78,7 +91,7 @@ TEST_F(SharedClipboardMessageHandlerTest,
        NotificationWithDeviceNameFromDeviceInfo) {
   std::string guid = base::GenerateGUID();
   {
-    EXPECT_CALL(*sharing_service_, GetDeviceByGuid(guid))
+    EXPECT_CALL(device_source_, GetDeviceByGuid(guid))
         .WillOnce(
             [](const std::string& guid) -> std::unique_ptr<syncer::DeviceInfo> {
               return std::make_unique<syncer::DeviceInfo>(
@@ -107,7 +120,7 @@ TEST_F(SharedClipboardMessageHandlerTest,
        NotificationWithDeviceNameFromMessage) {
   std::string guid = base::GenerateGUID();
   {
-    EXPECT_CALL(*sharing_service_, GetDeviceByGuid(guid))
+    EXPECT_CALL(device_source_, GetDeviceByGuid(guid))
         .WillOnce(
             [](const std::string& guid) -> std::unique_ptr<syncer::DeviceInfo> {
               return nullptr;

chrome/browser/sharing/shared_clipboard/shared_clipboard_test_base.cc

@@ -8,6 +8,7 @@
 #include "chrome/browser/notifications/notification_display_service_tester.h"
 #include "chrome/browser/sharing/mock_sharing_service.h"
 #include "components/sync/protocol/sharing_message.pb.h"
+#include "components/sync_device_info/device_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/test/test_clipboard.h"

chrome/browser/sharing/shared_clipboard/shared_clipboard_utils_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/test/scoped_feature_list.h"
 #include "chrome/browser/sharing/shared_clipboard/feature_flags.h"
 #include "chrome/browser/sharing/shared_clipboard/shared_clipboard_utils.h"
+#include "chrome/browser/sharing/sharing_device_source.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_service.h"
@@ -78,11 +79,10 @@ class SharedClipboardUtilsTest : public testing::Test {
             /*gcm_driver=*/nullptr, /*sharing_fcm_sender=*/nullptr,
             /*sync_preference=nullptr*/ nullptr),
         /*message_sender_=*/nullptr,
-        /* gcm_driver= */ nullptr,
-        /* device_info_tracker= */ nullptr,
-        /* local_device_info_provider= */ nullptr,
-        /* sync_service */ nullptr,
-        /* sms_fetcher= */ nullptr);
+        /*device_source=*/nullptr,
+        /*gcm_driver=*/nullptr,
+        /*sync_service=*/nullptr,
+        /*sms_fetcher=*/nullptr);
   }
 
   base::test::ScopedFeatureList scoped_feature_list_;

chrome/browser/sharing/sharing_browsertest.cc

@@ -13,6 +13,7 @@
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/sharing/sharing_device_registration_result.h"
+#include "chrome/browser/sharing/sharing_device_source_sync.h"
 #include "chrome/browser/sharing/sharing_service_factory.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
 #include "chrome/browser/sharing/sharing_target_info.h"
@@ -82,7 +83,8 @@ void SharingBrowserTest::RegisterDevice(
     sync_pb::SharingSpecificFields_EnabledFeatures feature) {
   SharingService* service =
       SharingServiceFactory::GetForBrowserContext(GetProfile(profile_index));
-  service->SetDeviceInfoTrackerForTesting(&fake_device_info_tracker_);
+  static_cast<SharingDeviceSourceSync*>(service->GetDeviceSource())
+      ->SetDeviceInfoTrackerForTesting(&fake_device_info_tracker_);
 
   base::RunLoop run_loop;
   service->RegisterDeviceInTesting(

chrome/browser/sharing/sharing_device_source.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 "chrome/browser/sharing/sharing_device_source.h"
+
+#include "base/callback.h"
+
+SharingDeviceSource::SharingDeviceSource() = default;
+
+SharingDeviceSource::~SharingDeviceSource() = default;
+
+void SharingDeviceSource::AddReadyCallback(base::OnceClosure callback) {
+  ready_callbacks_.push_back(std::move(callback));
+  MaybeRunReadyCallbacks();
+}
+
+void SharingDeviceSource::MaybeRunReadyCallbacks() {
+  if (!IsReady())
+    return;
+
+  for (auto& callback : ready_callbacks_)
+    std::move(callback).Run();
+
+  ready_callbacks_.clear();
+}

chrome/browser/sharing/sharing_device_source.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 CHROME_BROWSER_SHARING_SHARING_DEVICE_SOURCE_H_
+#define CHROME_BROWSER_SHARING_SHARING_DEVICE_SOURCE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/macros.h"
+
+namespace syncer {
+class DeviceInfo;
+}  // namespace syncer
+
+class SharingDeviceSource {
+ public:
+  SharingDeviceSource();
+  virtual ~SharingDeviceSource();
+
+  // Returns if the source is ready. Calling GetAllDevices before this is true
+  // returns an empty list.
+  virtual bool IsReady() = 0;
+
+  // Returns the device matching |guid|, or nullptr if no match was found.
+  virtual std::unique_ptr<syncer::DeviceInfo> GetDeviceByGuid(
+      const std::string& guid) = 0;
+
+  // Returns all devices found.
+  virtual std::vector<std::unique_ptr<syncer::DeviceInfo>> GetAllDevices() = 0;
+
+  void AddReadyCallback(base::OnceClosure callback);
+
+ protected:
+  void MaybeRunReadyCallbacks();
+
+ private:
+  std::vector<base::OnceClosure> ready_callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharingDeviceSource);
+};
+
+#endif  // CHROME_BROWSER_SHARING_SHARING_DEVICE_SOURCE_H_

chrome/browser/sharing/sharing_device_source_sync.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 "chrome/browser/sharing/sharing_device_source_sync.h"
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "base/callback.h"
+#include "base/stl_util.h"
+#include "base/task/post_task.h"
+#include "chrome/browser/sharing/sharing_utils.h"
+#include "components/sync/driver/sync_service.h"
+#include "components/sync_device_info/device_info.h"
+#include "components/sync_device_info/local_device_info_provider.h"
+#include "components/sync_device_info/local_device_info_util.h"
+#include "content/public/browser/browser_task_traits.h"
+
+SharingDeviceSourceSync::SharingDeviceSourceSync(
+    syncer::SyncService* sync_service,
+    syncer::LocalDeviceInfoProvider* local_device_info_provider,
+    syncer::DeviceInfoTracker* device_info_tracker)
+    : sync_service_(sync_service),
+      local_device_info_provider_(local_device_info_provider),
+      device_info_tracker_(device_info_tracker) {
+  base::PostTaskAndReplyWithResult(
+      FROM_HERE,
+      {base::ThreadPool(), base::MayBlock(),
+       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
+      base::BindOnce(syncer::GetPersonalizableDeviceNameBlocking),
+      base::BindOnce(
+          &SharingDeviceSourceSync::InitPersonalizableLocalDeviceName,
+          weak_ptr_factory_.GetWeakPtr()));
+
+  if (!device_info_tracker_->IsSyncing())
+    device_info_tracker_->AddObserver(this);
+
+  if (!local_device_info_provider_->GetLocalDeviceInfo()) {
+    local_device_info_ready_subscription_ =
+        local_device_info_provider_->RegisterOnInitializedCallback(
+            base::BindRepeating(
+                &SharingDeviceSourceSync::OnLocalDeviceInfoProviderReady,
+                weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+SharingDeviceSourceSync::~SharingDeviceSourceSync() {
+  device_info_tracker_->RemoveObserver(this);
+}
+
+std::unique_ptr<syncer::DeviceInfo> SharingDeviceSourceSync::GetDeviceByGuid(
+    const std::string& guid) {
+  if (!IsSyncEnabledForSharing(sync_service_))
+    return nullptr;
+
+  std::unique_ptr<syncer::DeviceInfo> device_info =
+      device_info_tracker_->GetDeviceInfo(guid);
+  if (!device_info)
+    return nullptr;
+
+  device_info->set_client_name(
+      GetSharingDeviceNames(device_info.get()).full_name);
+  return device_info;
+}
+
+std::vector<std::unique_ptr<syncer::DeviceInfo>>
+SharingDeviceSourceSync::GetAllDevices() {
+  if (!IsSyncEnabledForSharing(sync_service_) || !IsReady())
+    return {};
+
+  return RenameAndDeduplicateDevices(device_info_tracker_->GetAllDeviceInfo());
+}
+
+bool SharingDeviceSourceSync::IsReady() {
+  return IsSyncDisabledForSharing(sync_service_) ||
+         (personalizable_local_device_name_ &&
+          device_info_tracker_->IsSyncing() &&
+          local_device_info_provider_->GetLocalDeviceInfo());
+}
+
+void SharingDeviceSourceSync::OnDeviceInfoChange() {
+  if (device_info_tracker_->IsSyncing())
+    device_info_tracker_->RemoveObserver(this);
+  MaybeRunReadyCallbacks();
+}
+
+void SharingDeviceSourceSync::SetDeviceInfoTrackerForTesting(
+    syncer::DeviceInfoTracker* tracker) {
+  device_info_tracker_->RemoveObserver(this);
+  device_info_tracker_ = tracker;
+  if (!device_info_tracker_->IsSyncing())
+    device_info_tracker_->AddObserver(this);
+  MaybeRunReadyCallbacks();
+}
+
+void SharingDeviceSourceSync::InitPersonalizableLocalDeviceName(
+    std::string personalizable_local_device_name) {
+  personalizable_local_device_name_ =
+      std::move(personalizable_local_device_name);
+  MaybeRunReadyCallbacks();
+}
+
+void SharingDeviceSourceSync::OnLocalDeviceInfoProviderReady() {
+  DCHECK(local_device_info_provider_->GetLocalDeviceInfo());
+  local_device_info_ready_subscription_.reset();
+  MaybeRunReadyCallbacks();
+}
+
+std::vector<std::unique_ptr<syncer::DeviceInfo>>
+SharingDeviceSourceSync::RenameAndDeduplicateDevices(
+    std::vector<std::unique_ptr<syncer::DeviceInfo>> devices) const {
+  // Sort the devices so the most recently modified devices are first.
+  std::sort(devices.begin(), devices.end(),
+            [](const auto& device1, const auto& device2) {
+              return device1->last_updated_timestamp() >
+                     device2->last_updated_timestamp();
+            });
+
+  std::unordered_map<syncer::DeviceInfo*, SharingDeviceNames> device_names_map;
+  std::unordered_set<std::string> full_names;
+  std::unordered_map<std::string, int> short_names_counter;
+
+  // To prevent adding candidates with same full name as local device.
+  full_names.insert(
+      GetSharingDeviceNames(local_device_info_provider_->GetLocalDeviceInfo())
+          .full_name);
+  // To prevent M78- instances of Chrome with same device model from showing up.
+  full_names.insert(*personalizable_local_device_name_);
+
+  for (const auto& device : devices) {
+    SharingDeviceNames device_names = GetSharingDeviceNames(device.get());
+
+    // Only insert the first occurrence of each device name.
+    auto inserted = full_names.insert(device_names.full_name);
+    if (!inserted.second)
+      continue;
+
+    short_names_counter[device_names.short_name]++;
+    device_names_map.insert({device.get(), std::move(device_names)});
+  }
+
+  // Filter duplicates and rename devices.
+  base::EraseIf(devices, [&device_names_map,
+                          &short_names_counter](auto& device) {
+    auto it = device_names_map.find(device.get());
+    if (it == device_names_map.end())
+      return true;
+
+    const SharingDeviceNames& device_names = it->second;
+    bool unique_short_name = short_names_counter[device_names.short_name] == 1;
+    device->set_client_name(unique_short_name ? device_names.short_name
+                                              : device_names.full_name);
+    return false;
+  });
+
+  return devices;
+}

chrome/browser/sharing/sharing_device_source_sync.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 CHROME_BROWSER_SHARING_SHARING_DEVICE_SOURCE_SYNC_H_
+#define CHROME_BROWSER_SHARING_SHARING_DEVICE_SOURCE_SYNC_H_
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/sharing/sharing_device_source.h"
+#include "components/sync_device_info/device_info_tracker.h"
+#include "components/sync_device_info/local_device_info_provider.h"
+
+namespace syncer {
+class SyncService;
+class DeviceInfoTracker;
+}  // namespace syncer
+
+class SharingDeviceSourceSync : public SharingDeviceSource,
+                                public syncer::DeviceInfoTracker::Observer {
+ public:
+  SharingDeviceSourceSync(
+      syncer::SyncService* sync_service,
+      syncer::LocalDeviceInfoProvider* local_device_info_provider,
+      syncer::DeviceInfoTracker* device_info_tracker);
+  ~SharingDeviceSourceSync() override;
+
+  // SharingDeviceSource:
+  bool IsReady() override;
+  std::unique_ptr<syncer::DeviceInfo> GetDeviceByGuid(
+      const std::string& guid) override;
+  std::vector<std::unique_ptr<syncer::DeviceInfo>> GetAllDevices() override;
+
+  // syncer::DeviceInfoTracker::Observer:
+  void OnDeviceInfoChange() override;
+
+  // Used to fake client names in integration tests.
+  void SetDeviceInfoTrackerForTesting(syncer::DeviceInfoTracker* tracker);
+
+ private:
+  void InitPersonalizableLocalDeviceName(
+      std::string personalizable_local_device_name);
+
+  // Called by |local_device_info_provider_| when it is ready.
+  void OnLocalDeviceInfoProviderReady();
+
+  // Deduplicates devices based on their full name. For devices with duplicate
+  // full names, only the most recently updated device is returned. All devices
+  // are renamed to either their short name if that one is unique, or their full
+  // name otherwise. The returned list is sorted in (not strictly) descending
+  // order by last_updated_timestamp.
+  std::vector<std::unique_ptr<syncer::DeviceInfo>> RenameAndDeduplicateDevices(
+      std::vector<std::unique_ptr<syncer::DeviceInfo>> devices) const;
+
+  syncer::SyncService* sync_service_;
+  syncer::LocalDeviceInfoProvider* local_device_info_provider_;
+  syncer::DeviceInfoTracker* device_info_tracker_;
+  std::unique_ptr<syncer::LocalDeviceInfoProvider::Subscription>
+      local_device_info_ready_subscription_;
+
+  // The personalized name is stored for deduplicating devices running older
+  // clients.
+  base::Optional<std::string> personalizable_local_device_name_;
+
+  base::WeakPtrFactory<SharingDeviceSourceSync> weak_ptr_factory_{this};
+
+  DISALLOW_COPY_AND_ASSIGN(SharingDeviceSourceSync);
+};
+
+#endif  // CHROME_BROWSER_SHARING_SHARING_DEVICE_SOURCE_SYNC_H_

chrome/browser/sharing/sharing_device_source_sync_unittest.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 "chrome/browser/sharing/sharing_device_source_sync.h"
+
+#include <memory>
+
+#include "base/callback.h"
+#include "base/guid.h"
+#include "base/run_loop.h"
+#include "base/test/bind_test_util.h"
+#include "base/time/time.h"
+#include "chrome/browser/sharing/sharing_utils.h"
+#include "components/sync/driver/test_sync_service.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_local_device_info_provider.h"
+#include "components/sync_device_info/local_device_info_util.h"
+#include "content/public/test/browser_task_environment.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+std::unique_ptr<syncer::DeviceInfo> CreateDeviceInfo(
+    const std::string& client_name,
+    const base::SysInfo::HardwareInfo& hardware_info) {
+  return std::make_unique<syncer::DeviceInfo>(
+      base::GenerateGUID(), client_name, "chrome_version", "sync_user_agent",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id", hardware_info,
+      /*last_updated_timestamp=*/base::Time::Now(),
+      /*send_tab_to_self_receiving_enabled=*/false,
+      /*sharing_info=*/base::nullopt);
+}
+
+class SharingDeviceSourceSyncTest : public testing::Test {
+ public:
+  std::unique_ptr<SharingDeviceSourceSync> CreateDeviceSource(
+      bool wait_until_ready) {
+    auto device_source = std::make_unique<SharingDeviceSourceSync>(
+        &test_sync_service_, &fake_local_device_info_provider_,
+        &fake_device_info_tracker_);
+    if (!wait_until_ready)
+      return device_source;
+
+    if (!fake_device_info_tracker_.IsSyncing())
+      fake_device_info_tracker_.Add(local_device_info_);
+    fake_local_device_info_provider_.SetReady(true);
+
+    // Wait until local personalizable device
+    base::RunLoop run_loop;
+    device_source->AddReadyCallback(run_loop.QuitClosure());
+    run_loop.Run();
+
+    return device_source;
+  }
+
+ protected:
+  content::BrowserTaskEnvironment task_environment_{
+      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
+
+  syncer::TestSyncService test_sync_service_;
+  syncer::FakeLocalDeviceInfoProvider fake_local_device_info_provider_;
+  syncer::FakeDeviceInfoTracker fake_device_info_tracker_;
+  const syncer::DeviceInfo* local_device_info_ =
+      fake_local_device_info_provider_.GetLocalDeviceInfo();
+};
+
+}  // namespace
+
+TEST_F(SharingDeviceSourceSyncTest, RunsReadyCallback) {
+  fake_local_device_info_provider_.SetReady(false);
+  EXPECT_FALSE(fake_device_info_tracker_.IsSyncing());
+  EXPECT_FALSE(fake_local_device_info_provider_.GetLocalDeviceInfo());
+
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/false);
+
+  base::RunLoop run_loop;
+  bool did_run_callback = false;
+  device_source->AddReadyCallback(
+      base::BindLambdaForTesting([&did_run_callback, &run_loop]() {
+        did_run_callback = true;
+        run_loop.Quit();
+      }));
+  EXPECT_FALSE(did_run_callback);
+
+  // Make DeviceInfoTracker ready.
+  fake_device_info_tracker_.Add(local_device_info_);
+  EXPECT_FALSE(did_run_callback);
+
+  // Set LocalDeviceInfoProvider ready.
+  fake_local_device_info_provider_.SetReady(true);
+  EXPECT_FALSE(did_run_callback);
+
+  // Wait until local device name is ready.
+  run_loop.Run();
+  EXPECT_TRUE(did_run_callback);
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetDeviceByGuid_Ready) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/true);
+  EXPECT_TRUE(device_source->GetDeviceByGuid(local_device_info_->guid()));
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetDeviceByGuid_NotReady) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/false);
+  fake_device_info_tracker_.Add(local_device_info_);
+  // Even if local device is not ready we should be able to query devices.
+  EXPECT_TRUE(device_source->GetDeviceByGuid(local_device_info_->guid()));
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetDeviceByGuid_UnknownGuid) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/true);
+  EXPECT_FALSE(device_source->GetDeviceByGuid("unknown"));
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetDeviceByGuid_SyncDisabled) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/true);
+  test_sync_service_.SetTransportState(
+      syncer::SyncService::TransportState::DISABLED);
+  EXPECT_FALSE(device_source->GetDeviceByGuid(local_device_info_->guid()));
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetAllDevices_Ready) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/true);
+  auto device_info = CreateDeviceInfo("client_name", {});
+  fake_device_info_tracker_.Add(device_info.get());
+
+  auto devices = device_source->GetAllDevices();
+  ASSERT_EQ(1u, devices.size());
+  EXPECT_EQ(device_info->guid(), devices[0]->guid());
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetAllDevices_NotReady) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/false);
+  auto device_info = CreateDeviceInfo("client_name", {});
+  fake_device_info_tracker_.Add(device_info.get());
+  // Local device needs to be ready for deduplication.
+  EXPECT_TRUE(device_source->GetAllDevices().empty());
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetAllDevices_Deduplicated) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/true);
+
+  // Add two devices with the same |client_name| without hardware info.
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_1 = CreateDeviceInfo("client_name_1", {});
+  fake_device_info_tracker_.Add(device_info_1.get());
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_2 = CreateDeviceInfo("client_name_1", {});
+  fake_device_info_tracker_.Add(device_info_2.get());
+
+  // Add two devices with the same hardware info.
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_3 =
+      CreateDeviceInfo("client_name_2", {"manufacturer 1", "model 1"});
+  fake_device_info_tracker_.Add(device_info_3.get());
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_4 =
+      CreateDeviceInfo("client_name_3", {"manufacturer 1", "model 1"});
+  fake_device_info_tracker_.Add(device_info_4.get());
+
+  // Add a device with the same info as the local device.
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_5 = CreateDeviceInfo(local_device_info_->client_name(),
+                                        local_device_info_->hardware_info());
+  fake_device_info_tracker_.Add(device_info_5.get());
+
+  // Add a device with the local personalizable device name as client_name to
+  // simulate old versions without hardware info.
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_6 =
+      CreateDeviceInfo(syncer::GetPersonalizableDeviceNameBlocking(), {});
+  fake_device_info_tracker_.Add(device_info_6.get());
+
+  auto devices = device_source->GetAllDevices();
+  ASSERT_EQ(2u, devices.size());
+  EXPECT_EQ(device_info_4->guid(), devices[0]->guid());
+  EXPECT_EQ(device_info_2->guid(), devices[1]->guid());
+}
+
+TEST_F(SharingDeviceSourceSyncTest, GetAllDevices_DeviceNaming) {
+  auto device_source = CreateDeviceSource(/*wait_until_ready=*/true);
+
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_1 = CreateDeviceInfo("client_name", {});
+  fake_device_info_tracker_.Add(device_info_1.get());
+
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_2 = CreateDeviceInfo("name", {"manufacturer 1", "model 1"});
+  fake_device_info_tracker_.Add(device_info_2.get());
+
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_3 = CreateDeviceInfo("name", {"manufacturer 1", "model 2"});
+  fake_device_info_tracker_.Add(device_info_3.get());
+
+  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(10));
+  auto device_info_4 = CreateDeviceInfo("name", {"manufacturer 2", "model 1"});
+  fake_device_info_tracker_.Add(device_info_4.get());
+
+  auto devices = device_source->GetAllDevices();
+  ASSERT_EQ(4u, devices.size());
+  EXPECT_EQ(GetSharingDeviceNames(device_info_4.get()).short_name,
+            devices[0]->client_name());
+  EXPECT_EQ(GetSharingDeviceNames(device_info_3.get()).full_name,
+            devices[1]->client_name());
+  EXPECT_EQ(GetSharingDeviceNames(device_info_2.get()).full_name,
+            devices[2]->client_name());
+  EXPECT_EQ(GetSharingDeviceNames(device_info_1.get()).short_name,
+            devices[3]->client_name());
+}

chrome/browser/sharing/sharing_device_source_unittest.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 "chrome/browser/sharing/sharing_device_source.h"
+
+#include "base/callback.h"
+#include "base/test/bind_test_util.h"
+#include "components/sync_device_info/device_info.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class MockSharingDeviceSource : public SharingDeviceSource {
+ public:
+  MOCK_METHOD0(IsReady, bool());
+
+  MOCK_METHOD1(GetDeviceByGuid,
+               std::unique_ptr<syncer::DeviceInfo>(const std::string& guid));
+
+  MOCK_METHOD0(GetAllDevices,
+               std::vector<std::unique_ptr<syncer::DeviceInfo>>());
+
+  void MaybeRunReadyCallbacksForTesting() { MaybeRunReadyCallbacks(); }
+};
+
+}  // namespace
+
+TEST(SharingDeviceSourceTest, RunsCallbackImmediatelyIfReady) {
+  MockSharingDeviceSource device_source;
+  EXPECT_CALL(device_source, IsReady()).WillOnce(testing::Return(true));
+
+  bool did_run_callback = false;
+  device_source.AddReadyCallback(base::BindLambdaForTesting(
+      [&did_run_callback]() { did_run_callback = true; }));
+
+  EXPECT_TRUE(did_run_callback);
+}
+
+TEST(SharingDeviceSourceTest, RunsCallbackAfterIsReady) {
+  MockSharingDeviceSource device_source;
+  EXPECT_CALL(device_source, IsReady())
+      .WillOnce(testing::Return(false))
+      .WillOnce(testing::Return(true));
+
+  bool did_run_callback = false;
+  device_source.AddReadyCallback(base::BindLambdaForTesting(
+      [&did_run_callback]() { did_run_callback = true; }));
+  EXPECT_FALSE(did_run_callback);
+
+  device_source.MaybeRunReadyCallbacksForTesting();
+  EXPECT_TRUE(did_run_callback);
+}

chrome/browser/sharing/sharing_service.h

@@ -11,7 +11,6 @@
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
-#include "base/optional.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/sharing/ack_message_handler.h"
@@ -21,12 +20,9 @@
 #include "chrome/browser/sharing/sharing_send_message_result.h"
 #include "components/gcm_driver/web_push_common.h"
 #include "components/keyed_service/core/keyed_service.h"
-#include "components/sync/base/model_type.h"
 #include "components/sync/driver/sync_service_observer.h"
 #include "components/sync/protocol/device_info_specifics.pb.h"
 #include "components/sync/protocol/sharing_message.pb.h"
-#include "components/sync_device_info/device_info_tracker.h"
-#include "components/sync_device_info/local_device_info_provider.h"
 #include "net/base/backoff_entry.h"
 
 #if defined(OS_ANDROID)
@@ -55,13 +51,12 @@ class SharingFCMSender;
 class SharingSyncPreference;
 class SmsFetchRequestHandler;
 class VapidKeyManager;
+class SharingDeviceSource;
 enum class SharingDeviceRegistrationResult;
 
 // Class to manage lifecycle of sharing feature, and provide APIs to send
 // sharing messages to other devices.
-class SharingService : public KeyedService,
-                       syncer::SyncServiceObserver,
-                       syncer::DeviceInfoTracker::Observer {
+class SharingService : public KeyedService, syncer::SyncServiceObserver {
  public:
   using SharingDeviceList = std::vector<std::unique_ptr<syncer::DeviceInfo>>;
 
@@ -83,10 +78,9 @@ class SharingService : public KeyedService,
       std::unique_ptr<SharingDeviceRegistration> sharing_device_registration,
       std::unique_ptr<SharingFCMSender> fcm_sender,
       std::unique_ptr<SharingFCMHandler> fcm_handler,
-      std::unique_ptr<SharingMessageSender> message_sender_,
+      std::unique_ptr<SharingMessageSender> message_sender,
+      std::unique_ptr<SharingDeviceSource> device_source,
       gcm::GCMDriver* gcm_driver,
-      syncer::DeviceInfoTracker* device_info_tracker,
-      syncer::LocalDeviceInfoProvider* local_device_info_provider,
       syncer::SyncService* sync_service,
       content::SmsFetcher* sms_fetcher);
   ~SharingService() override;
@@ -100,10 +94,6 @@ class SharingService : public KeyedService,
   virtual SharingDeviceList GetDeviceCandidates(
       sync_pb::SharingSpecificFields::EnabledFeatures required_feature) const;
 
-  // Register |callback| so it will be invoked after all dependencies of
-  // GetDeviceCandidates are ready.
-  void AddDeviceCandidatesInitializedObserver(base::OnceClosure callback);
-
   // Sends a Sharing message to remote device.
   // |device_guid|: Sync GUID of receiver device.
   // |response_timeout|: Maximum amount of time waiting for a response before
@@ -122,8 +112,7 @@ class SharingService : public KeyedService,
       std::set<sync_pb::SharingSpecificFields_EnabledFeatures> enabled_features,
       SharingDeviceRegistration::RegistrationCallback callback);
 
-  // Used to fake client names in integration tests.
-  void SetDeviceInfoTrackerForTesting(syncer::DeviceInfoTracker* tracker);
+  SharingDeviceSource* GetDeviceSource() const;
 
   // Returns the current state of SharingService for testing.
   State GetStateForTesting() const;
@@ -140,9 +129,6 @@ class SharingService : public KeyedService,
   void OnStateChanged(syncer::SyncService* sync) override;
   void OnSyncCycleCompleted(syncer::SyncService* sync) override;
 
-  // syncer::DeviceInfoTracker::Observer.
-  void OnDeviceInfoChange() override;
-
   void RefreshVapidKey();
   void RegisterDevice();
   void UnregisterDevice();
@@ -150,16 +136,6 @@ class SharingService : public KeyedService,
   void OnDeviceRegistered(SharingDeviceRegistrationResult result);
   void OnDeviceUnregistered(SharingDeviceRegistrationResult result);
 
-  // Returns true if required sync feature is enabled.
-  bool IsSyncEnabled() const;
-
-  // Returns true if required sync feature is disabled. Returns false if sync is
-  // in transitioning state.
-  bool IsSyncDisabled() const;
-
-  // Returns all required sync data types to enable Sharing feature.
-  syncer::ModelTypeSet GetRequiredSyncDataTypes() const;
-
   // Returns list of devices that have |required_feature| enabled. Also
   // filters out devices which have not been online for more than
   // |SharingConstants::kDeviceExpiration| time.
@@ -167,39 +143,18 @@ class SharingService : public KeyedService,
       SharingDeviceList devices,
       sync_pb::SharingSpecificFields::EnabledFeatures required_feature) const;
 
-  // Deduplicates devices based on client name. For devices with duplicate
-  // client names, only the most recently updated device is filtered in.
-  // Returned devices are renamed using the RenameDevice function
-  // and are sorted in (not strictly) descending order by
-  // last_updated_timestamp.
-  SharingDeviceList RenameAndDeduplicateDevices(
-      SharingDeviceList devices) const;
-
-  void InitPersonalizableLocalDeviceName(
-      std::string personalizable_local_device_name);
-
   std::unique_ptr<SharingSyncPreference> sync_prefs_;
   std::unique_ptr<VapidKeyManager> vapid_key_manager_;
   std::unique_ptr<SharingDeviceRegistration> sharing_device_registration_;
   std::unique_ptr<SharingFCMSender> fcm_sender_;
   std::unique_ptr<SharingFCMHandler> fcm_handler_;
   std::unique_ptr<SharingMessageSender> message_sender_;
+  std::unique_ptr<SharingDeviceSource> device_source_;
 
-  syncer::DeviceInfoTracker* device_info_tracker_;
-  syncer::LocalDeviceInfoProvider* local_device_info_provider_;
   syncer::SyncService* sync_service_;
 
   net::BackoffEntry backoff_entry_;
   State state_;
-  bool is_observing_device_info_tracker_;
-  std::unique_ptr<syncer::LocalDeviceInfoProvider::Subscription>
-      local_device_info_ready_subscription_;
-  // The personalized name is stored for deduplicating devices running older
-  // clients.
-  base::Optional<std::string> personalizable_local_device_name_;
-
-  // List of callbacks for AddDeviceCandidatesInitializedObserver.
-  std::vector<base::OnceClosure> device_candidates_initialized_callbacks_;
 
 #if defined(OS_ANDROID)
   SharingServiceProxyAndroid sharing_service_proxy_android_{this};

chrome/browser/sharing/sharing_service_factory.cc

@@ -11,6 +11,7 @@
 #include "chrome/browser/gcm/instance_id/instance_id_profile_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sharing/sharing_device_registration.h"
+#include "chrome/browser/sharing/sharing_device_source_sync.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_message_sender.h"
@@ -101,12 +102,15 @@ KeyedService* SharingServiceFactory::BuildServiceInstanceFor(
 
   content::SmsFetcher* sms_fetcher = content::SmsFetcher::Get(context);
 
+  std::unique_ptr<SharingDeviceSource> device_source =
+      std::make_unique<SharingDeviceSourceSync>(
+          sync_service, local_device_info_provider, device_info_tracker);
+
   return new SharingService(
       profile, std::move(sync_prefs), std::move(vapid_key_manager),
       std::move(sharing_device_registration), std::move(fcm_sender),
-      std::move(fcm_handler), std::move(sharing_message_sender), gcm_driver,
-      device_info_tracker, local_device_info_provider, sync_service,
-      sms_fetcher);
+      std::move(fcm_handler), std::move(sharing_message_sender),
+      std::move(device_source), gcm_driver, sync_service, sms_fetcher);
 }
 
 content::BrowserContext* SharingServiceFactory::GetBrowserContextToUse(

chrome/browser/sharing/sharing_service_proxy_android.cc

@@ -10,6 +10,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/sharing/sharing_constants.h"
+#include "chrome/browser/sharing/sharing_device_source.h"
 #include "chrome/browser/sharing/sharing_send_message_result.h"
 #include "chrome/browser/sharing/sharing_service.h"
 #include "chrome/browser/sharing/sharing_service_factory.h"
@@ -84,7 +85,7 @@ void SharingServiceProxyAndroid::GetDeviceCandidates(
 void SharingServiceProxyAndroid::AddDeviceCandidatesInitializedObserver(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& j_runnable) {
-  sharing_service_->AddDeviceCandidatesInitializedObserver(
+  sharing_service_->GetDeviceSource()->AddReadyCallback(
       base::BindOnce(base::android::RunRunnableAndroid,
                      base::android::ScopedJavaGlobalRef<jobject>(j_runnable)));
 }

chrome/browser/sharing/sharing_service_unittest.cc

@@ -16,6 +16,7 @@
 #include "chrome/browser/sharing/sharing_constants.h"
 #include "chrome/browser/sharing/sharing_device_registration.h"
 #include "chrome/browser/sharing/sharing_device_registration_result.h"
+#include "chrome/browser/sharing/sharing_device_source_sync.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
@@ -212,10 +213,12 @@ class SharingServiceTest : public testing::Test {
           base::WrapUnique(vapid_key_manager_),
           base::WrapUnique(sharing_device_registration_), nullptr,
           base::WrapUnique(fcm_handler_),
-          base::WrapUnique(sharing_message_sender_), nullptr,
-          fake_device_info_sync_service.GetDeviceInfoTracker(),
-          fake_device_info_sync_service.GetLocalDeviceInfoProvider(),
-          &test_sync_service_,
+          base::WrapUnique(sharing_message_sender_),
+          std::make_unique<SharingDeviceSourceSync>(
+              &test_sync_service_,
+              fake_device_info_sync_service.GetLocalDeviceInfoProvider(),
+              fake_device_info_sync_service.GetDeviceInfoTracker()),
+          /*gcm_driver=*/nullptr, &test_sync_service_,
           /* sms_fetcher= */ nullptr);
     }
     task_environment_.RunUntilIdle();
@@ -716,7 +719,7 @@ TEST_F(SharingServiceTest, DeviceCandidatesAlreadyReady) {
   fake_device_info_sync_service.GetDeviceInfoTracker()->Add(device_info.get());
   fake_device_info_sync_service.GetLocalDeviceInfoProvider()->SetReady(true);
 
-  GetSharingService()->AddDeviceCandidatesInitializedObserver(
+  GetSharingService()->GetDeviceSource()->AddReadyCallback(
       base::BindOnce(&SharingServiceTest::OnDeviceCandidatesInitialized,
                      base::Unretained(this)));
 
@@ -726,7 +729,7 @@ TEST_F(SharingServiceTest, DeviceCandidatesAlreadyReady) {
 TEST_F(SharingServiceTest, DeviceCandidatesReadyAfterAddObserver) {
   fake_device_info_sync_service.GetLocalDeviceInfoProvider()->SetReady(false);
 
-  GetSharingService()->AddDeviceCandidatesInitializedObserver(
+  GetSharingService()->GetDeviceSource()->AddReadyCallback(
       base::BindOnce(&SharingServiceTest::OnDeviceCandidatesInitialized,
                      base::Unretained(this)));
 

chrome/browser/sharing/sharing_utils.cc

@@ -4,8 +4,11 @@
 
 #include "chrome/browser/sharing/sharing_utils.h"
 
+#include "base/feature_list.h"
 #include "base/strings/strcat.h"
+#include "chrome/browser/sharing/features.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/sync/driver/sync_service.h"
 #include "components/sync_device_info/device_info.h"
 #include "ui/base/l10n/l10n_util.h"
 
@@ -49,6 +52,19 @@ std::string CapitalizeWords(const std::string& sentence) {
   return capitalized_sentence;
 }
 
+syncer::ModelTypeSet GetRequiredSyncDataTypes() {
+  // DeviceInfo is always required to list devices.
+  syncer::ModelTypeSet required_data_types(syncer::DEVICE_INFO);
+
+  // Legacy implementation of device list and VAPID key uses sync preferences.
+  if (!base::FeatureList::IsEnabled(kSharingUseDeviceInfo) ||
+      !base::FeatureList::IsEnabled(kSharingDeriveVapidKey)) {
+    required_data_types.Put(syncer::PREFERENCES);
+  }
+
+  return required_data_types;
+}
+
 }  // namespace
 
 SharingDeviceNames GetSharingDeviceNames(const syncer::DeviceInfo* device) {
@@ -89,3 +105,35 @@ SharingDeviceNames GetSharingDeviceNames(const syncer::DeviceInfo* device) {
       base::StrCat({device_names.short_name, " ", hardware_info.model});
   return device_names;
 }
+
+bool IsSyncEnabledForSharing(syncer::SyncService* sync_service) {
+  if (!sync_service)
+    return false;
+
+  bool is_sync_enabled =
+      sync_service->GetTransportState() ==
+          syncer::SyncService::TransportState::ACTIVE &&
+      sync_service->GetActiveDataTypes().HasAll(GetRequiredSyncDataTypes());
+  // TODO(crbug.com/1012226): Remove local sync check when we have dedicated
+  // Sharing data type.
+  if (base::FeatureList::IsEnabled(kSharingDeriveVapidKey))
+    is_sync_enabled &= !sync_service->IsLocalSyncEnabled();
+  return is_sync_enabled;
+}
+
+bool IsSyncDisabledForSharing(syncer::SyncService* sync_service) {
+  if (!sync_service)
+    return false;
+
+  bool is_sync_disabled =
+      sync_service->GetTransportState() ==
+          syncer::SyncService::TransportState::DISABLED ||
+      (sync_service->GetTransportState() ==
+           syncer::SyncService::TransportState::ACTIVE &&
+       !sync_service->GetActiveDataTypes().HasAll(GetRequiredSyncDataTypes()));
+  // TODO(crbug.com/1012226): Remove local sync check when we have dedicated
+  // Sharing data type.
+  if (base::FeatureList::IsEnabled(kSharingDeriveVapidKey))
+    is_sync_disabled |= sync_service->IsLocalSyncEnabled();
+  return is_sync_disabled;
+}

chrome/browser/sharing/sharing_utils.h

@@ -9,6 +9,7 @@
 
 namespace syncer {
 class DeviceInfo;
+class SyncService;
 }  // namespace syncer
 
 struct SharingDeviceNames {
@@ -19,4 +20,10 @@ struct SharingDeviceNames {
 // Returns full and short names for |device|.
 SharingDeviceNames GetSharingDeviceNames(const syncer::DeviceInfo* device);
 
+// Returns true if required sync feature is enabled.
+bool IsSyncEnabledForSharing(syncer::SyncService* sync_service);
+
+// Returns true if required sync feature is disabled.
+bool IsSyncDisabledForSharing(syncer::SyncService* sync_service);
+
 #endif  // CHROME_BROWSER_SHARING_SHARING_UTILS_H_

chrome/browser/sharing/sms/sms_remote_fetcher_unittest.cc

@@ -13,6 +13,7 @@
 #include "chrome/browser/sharing/sms/sms_flags.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync/protocol/sharing_message.pb.h"
+#include "components/sync_device_info/device_info.h"
 #include "content/public/browser/sms_fetcher.h"
 #include "content/public/test/browser_task_environment.h"
 #include "testing/gmock/include/gmock/gmock.h"

chrome/test/BUILD.gn

@@ -3240,6 +3240,8 @@ test("unit_tests") {
     "../browser/sharing/mock_sharing_service.cc",
     "../browser/sharing/mock_sharing_service.h",
     "../browser/sharing/sharing_device_registration_unittest.cc",
+    "../browser/sharing/sharing_device_source_sync_unittest.cc",
+    "../browser/sharing/sharing_device_source_unittest.cc",
     "../browser/sharing/sharing_fcm_handler_unittest.cc",
     "../browser/sharing/sharing_fcm_sender_unittest.cc",
     "../browser/sharing/sharing_message_sender_unittest.cc",