blob: 1c434f6858d46af798b485e42603908684ca460f (
plain)
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
|
// Copyright 2015 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 REMOTING_PROTOCOL_TRANSPORT_CONTEXT_H_
#define REMOTING_PROTOCOL_TRANSPORT_CONTEXT_H_
#include <array>
#include <list>
#include <string>
#include <vector>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "remoting/protocol/ice_config.h"
#include "remoting/protocol/network_settings.h"
#include "remoting/protocol/transport.h"
namespace remoting {
class SignalStrategy;
class UrlRequestFactory;
namespace protocol {
class PortAllocatorFactory;
class IceConfigRequest;
// TransportContext is responsible for storing all parameters required for
// P2P transport initialization. It's also responsible for fetching STUN and
// TURN configuration.
class TransportContext : public base::RefCountedThreadSafe<TransportContext> {
public:
enum RelayMode {
GTURN,
TURN,
LAST_RELAYMODE = TURN
};
static const int kNumRelayModes = RelayMode::LAST_RELAYMODE + 1;
typedef base::Callback<void(const IceConfig& ice_config)>
GetIceConfigCallback;
static scoped_refptr<TransportContext> ForTests(TransportRole role);
TransportContext(SignalStrategy* signal_strategy,
scoped_ptr<PortAllocatorFactory> port_allocator_factory,
scoped_ptr<UrlRequestFactory> url_request_factory,
const NetworkSettings& network_settings,
TransportRole role);
void set_ice_config_url(const std::string& ice_config_url) {
ice_config_url_ = ice_config_url;
}
// Sets relay mode for all future calls of GetIceConfig(). Doesn't affect
// previous GetIceConfig() requests.
void set_relay_mode(RelayMode relay_mode) { relay_mode_ = relay_mode; }
// Prepares fresh JingleInfo. It may be called while connection is being
// negotiated to minimize the chance that the following GetIceConfig() will
// be blocking.
void Prepare();
// Requests fresh STUN and TURN information.
void GetIceConfig(const GetIceConfigCallback& callback);
PortAllocatorFactory* port_allocator_factory() {
return port_allocator_factory_.get();
}
UrlRequestFactory* url_request_factory() {
return url_request_factory_.get();
}
const NetworkSettings& network_settings() const { return network_settings_; }
TransportRole role() const { return role_; }
private:
friend class base::RefCountedThreadSafe<TransportContext>;
~TransportContext();
void EnsureFreshIceConfig();
void OnIceConfig(RelayMode relay_mode, const IceConfig& ice_config);
SignalStrategy* signal_strategy_;
scoped_ptr<PortAllocatorFactory> port_allocator_factory_;
scoped_ptr<UrlRequestFactory> url_request_factory_;
NetworkSettings network_settings_;
TransportRole role_;
std::string ice_config_url_;
RelayMode relay_mode_ = RelayMode::GTURN;
std::array<scoped_ptr<IceConfigRequest>, kNumRelayModes> ice_config_request_;
std::array<IceConfig, kNumRelayModes> ice_config_;
// When there is an active |ice_config_request_| stores list of callbacks to
// be called once the request is finished.
std::array<std::list<GetIceConfigCallback>, kNumRelayModes>
pending_ice_config_callbacks_;
DISALLOW_COPY_AND_ASSIGN(TransportContext);
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_TRANSPORT_CONTEXT_H_
|
