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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// Copyright 2020 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_ASH_SECURE_CHANNEL_NEARBY_CONNECTOR_IMPL_H_
#define CHROME_BROWSER_ASH_SECURE_CHANNEL_NEARBY_CONNECTOR_IMPL_H_
#include <memory>
#include <vector>
#include "base/containers/flat_map.h"
#include "base/containers/queue.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/unguessable_token.h"
#include "chromeos/ash/services/nearby/public/cpp/nearby_process_manager.h"
#include "chromeos/ash/services/secure_channel/public/cpp/client/nearby_connector.h"
#include "chromeos/ash/services/secure_channel/public/mojom/nearby_connector.mojom-shared.h"
#include "chromeos/ash/services/secure_channel/public/mojom/nearby_connector.mojom.h"
#include "components/keyed_service/core/keyed_service.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
namespace ash {
namespace secure_channel {
class NearbyConnectionBroker;
class NearbyEndpointFinder;
// NearbyConnector implementation which uses NearbyProcessManager to interact
// with Nearby Connections. When a connection is requested, NearbyConnectorImpl
// obtains a reference to the Nearby utility process, and when no requests are
// active, the class releases its reference.
//
// Because only one NearbyEndpointFinder is meant to be used at a time,
// connections are connected in a queue; once one connection has been
// established, it is possible for a new one to be requested. The class
// assigns an ID to each connection and holds a reference to a
// NearbyConnectionBroker for each one.
class NearbyConnectorImpl : public NearbyConnector, public KeyedService {
public:
explicit NearbyConnectorImpl(
nearby::NearbyProcessManager* nearby_process_manager);
~NearbyConnectorImpl() override;
private:
struct ConnectionRequestMetadata {
ConnectionRequestMetadata(
const std::vector<uint8_t>& bluetooth_public_address,
const std::vector<uint8_t>& eid,
mojo::PendingRemote<mojom::NearbyMessageReceiver> message_receiver,
mojo::PendingRemote<mojom::NearbyConnectionStateListener>
nearby_connection_state_listener,
NearbyConnector::ConnectCallback callback);
ConnectionRequestMetadata(const ConnectionRequestMetadata&) = delete;
ConnectionRequestMetadata& operator=(const ConnectionRequestMetadata&) =
delete;
~ConnectionRequestMetadata();
std::vector<uint8_t> bluetooth_public_address;
std::vector<uint8_t> eid;
mojo::PendingRemote<mojom::NearbyMessageReceiver> message_receiver;
mojo::PendingRemote<mojom::NearbyConnectionStateListener>
nearby_connection_state_listener;
NearbyConnector::ConnectCallback callback;
};
struct ActiveConnectionAttempt {
ActiveConnectionAttempt(
const base::UnguessableToken& attempt_id,
std::unique_ptr<NearbyEndpointFinder> endpoint_finder,
NearbyConnector::ConnectCallback callback);
~ActiveConnectionAttempt();
base::UnguessableToken attempt_id;
std::unique_ptr<NearbyEndpointFinder> endpoint_finder;
NearbyConnector::ConnectCallback callback;
};
/// mojom::NearbyConnector:
void Connect(
const std::vector<uint8_t>& bluetooth_public_address,
const std::vector<uint8_t>& eid,
mojo::PendingRemote<mojom::NearbyMessageReceiver> message_receiver,
mojo::PendingRemote<mojom::NearbyConnectionStateListener>
nearby_connection_state_listener,
NearbyConnector::ConnectCallback callback) override;
// KeyedService:
void Shutdown() override;
void ClearActiveAndPendingConnections();
void ProcessQueuedConnectionRequests();
void OnNearbyProcessStopped(
nearby::NearbyProcessManager::NearbyProcessShutdownReason
shutdown_reason);
void RecordNearbyDisconnectionForActiveBrokers(
nearby::NearbyProcessManager::NearbyProcessShutdownReason
shutdown_reason);
void OnConnected(const base::UnguessableToken& id,
mojo::PendingRemote<mojom::NearbyMessageSender>
message_sender_pending_remote,
mojo::PendingRemote<mojom::NearbyFilePayloadHandler>
file_payload_handler_remote);
void OnDisconnected(const base::UnguessableToken& id);
void InvokeActiveConnectionAttemptCallback(
mojo::PendingRemote<mojom::NearbyMessageSender>
message_sender_pending_remote,
mojo::PendingRemote<mojom::NearbyFilePayloadHandler>
file_payload_handler_remote);
raw_ptr<nearby::NearbyProcessManager> nearby_process_manager_;
// Reference to the Nearby utility process; null if we have not requested a
// connection to the process (i.e., when there are no active connection
// requests).
std::unique_ptr<nearby::NearbyProcessManager::NearbyProcessReference>
process_reference_;
// Metadata for connection requests which are planned but not yet started.
base::queue<std::unique_ptr<ConnectionRequestMetadata>>
queued_connection_requests_;
// Active connection brokers, which delegate messages between Nearby
// Connections and SecureChannel. This map can contain at most one broker
// which is in the process of connecting and any number of active connections.
// If a broker is currently pending a connection, its ID is stored in
// |broker_id_pending_connection_|.
base::flat_map<base::UnguessableToken,
std::unique_ptr<NearbyConnectionBroker>>
id_to_brokers_map_;
// Metadata for an ongoing connection attempt. If this field is set, it means
// that the entry in |id_to_brokers_map_| with the given ID is currently
// attempting a connection. If null, there is no pending connection attempt.
std::optional<ActiveConnectionAttempt> active_connection_attempt_;
base::WeakPtrFactory<NearbyConnectorImpl> weak_ptr_factory_{this};
};
} // namespace secure_channel
} // namespace ash
#endif // CHROME_BROWSER_ASH_SECURE_CHANNEL_NEARBY_CONNECTOR_IMPL_H_
|
