Commit cd7072bf authored by Richard Knoll's avatar Richard Knoll Committed by Commit Bot

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: default avatarAlex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715289}
parent b314bc03
......@@ -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",
......
......@@ -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_;
......
......@@ -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) {}
......
......@@ -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);
......
......@@ -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);
};
......
......@@ -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;
......
......@@ -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:
......
......@@ -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;
......
......@@ -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;
......
......@@ -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;
......
......@@ -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"
......
......@@ -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_;
......
......@@ -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(
......
// 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();
}
// 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_
// 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;
}
// 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_
// 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());
}
// 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);
}
This diff is collapsed.
......@@ -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};
......
......@@ -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(
......
......@@ -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)));
}
......@@ -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)));
......
......@@ -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;
}
......@@ -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_
......@@ -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"
......
......@@ -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",
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment