1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright 2024 The Chromium Authors
// 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_REGISTRATION_IMPL_H_
#define CHROME_BROWSER_SHARING_SHARING_DEVICE_REGISTRATION_IMPL_H_
#include <optional>
#include <string>
#include "base/functional/callback.h"
#include "base/gtest_prod_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "components/gcm_driver/instance_id/instance_id.h"
#include "components/sync/protocol/device_info_specifics.pb.h"
#include "components/sync_device_info/device_info.h"
#include "components/sharing_message/sharing_device_registration.h"
class PrefService;
namespace instance_id {
class InstanceIDDriver;
} // namespace instance_id
namespace syncer {
class SyncService;
} // namespace syncer
enum class SharingDeviceRegistrationResult;
class SharingSyncPreference;
class VapidKeyManager;
// Responsible for registering and unregistering device with
// SharingSyncPreference.
class SharingDeviceRegistrationImpl : public SharingDeviceRegistration {
public:
using RegistrationCallback =
base::OnceCallback<void(SharingDeviceRegistrationResult)>;
using TargetInfoCallback = base::OnceCallback<void(
SharingDeviceRegistrationResult,
std::optional<syncer::DeviceInfo::SharingTargetInfo>)>;
SharingDeviceRegistrationImpl(PrefService* pref_service,
SharingSyncPreference* prefs,
VapidKeyManager* vapid_key_manager,
instance_id::InstanceIDDriver* instance_id_driver,
syncer::SyncService* sync_service);
SharingDeviceRegistrationImpl(const SharingDeviceRegistrationImpl&) = delete;
SharingDeviceRegistrationImpl& operator=(const SharingDeviceRegistrationImpl&) =
delete;
~SharingDeviceRegistrationImpl() override;
// Registers device with sharing sync preferences. Takes a |callback| function
// which receives the result of FCM registration for device.
void RegisterDevice(RegistrationCallback callback) override;
// Un-registers device with sharing sync preferences.
void UnregisterDevice(RegistrationCallback callback) override;
// Returns if device can handle receiving phone numbers for calling.
bool IsClickToCallSupported() const override;
// Returns if device can handle receiving of shared clipboard contents.
bool IsSharedClipboardSupported() const override;
// Returns if device can handle receiving of sms fetcher requests.
bool IsSmsFetcherSupported() const override;
// Returns if device can handle receiving of remote copy contents.
bool IsRemoteCopySupported() const override;
// Returns if device can handle receiving of optimization guide push
// notification.
bool IsOptimizationGuidePushNotificationSupported() const override;
// For testing
void SetEnabledFeaturesForTesting(
std::set<sync_pb::SharingSpecificFields_EnabledFeatures>
enabled_features) override;
private:
FRIEND_TEST_ALL_PREFIXES(SharingDeviceRegistrationImplTest,
RegisterDeviceTest_Success);
void RetrieveTargetInfo(const std::string& sender_id,
TargetInfoCallback callback);
void OnFCMTokenReceived(TargetInfoCallback callback,
const std::string& sender_id,
const std::string& fcm_token,
instance_id::InstanceID::Result result);
void OnEncryptionInfoReceived(TargetInfoCallback callback,
const std::string& fcm_token,
std::string p256dh,
std::string auth_secret);
void OnSharingTargetInfoRetrieved(
RegistrationCallback callback,
SharingDeviceRegistrationResult result,
std::optional<syncer::DeviceInfo::SharingTargetInfo> sharing_target_info);
void OnVapidFCMTokenDeleted(RegistrationCallback callback,
SharingDeviceRegistrationResult result);
void DeleteFCMToken(const std::string& authorized_entity,
RegistrationCallback callback);
void OnFCMTokenDeleted(RegistrationCallback callback,
instance_id::InstanceID::Result result);
// Computes and returns a set of all enabled features on the device.
std::set<sync_pb::SharingSpecificFields_EnabledFeatures> GetEnabledFeatures()
const;
raw_ptr<PrefService> pref_service_;
raw_ptr<SharingSyncPreference> sharing_sync_preference_;
raw_ptr<VapidKeyManager> vapid_key_manager_;
raw_ptr<instance_id::InstanceIDDriver> instance_id_driver_;
raw_ptr<syncer::SyncService> sync_service_;
std::optional<std::set<sync_pb::SharingSpecificFields_EnabledFeatures>>
enabled_features_testing_value_;
base::WeakPtrFactory<SharingDeviceRegistrationImpl> weak_ptr_factory_{this};
};
#endif // CHROME_BROWSER_SHARING_SHARING_DEVICE_REGISTRATION_IMPL_H_
|
