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
146
147
148
149
150
151
|
// Copyright (c) 2012 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 CONTENT_RENDERER_P2P_PORT_ALLOCATOR_H_
#define CONTENT_RENDERER_P2P_PORT_ALLOCATOR_H_
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "net/base/net_util.h"
#include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
#include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
namespace blink {
class WebFrame;
class WebURLLoader;
} // namespace blink
namespace content {
class P2PHostAddressRequest;
class P2PPortAllocatorSession;
class P2PSocketDispatcher;
// TODO(sergeyu): There is overlap between this class and HttpPortAllocator.
// Refactor this class to inherit from HttpPortAllocator to avoid code
// duplication.
class P2PPortAllocator : public cricket::BasicPortAllocator {
public:
struct Config {
Config();
~Config();
struct RelayServerConfig {
RelayServerConfig();
~RelayServerConfig();
std::string username;
std::string password;
std::string server_address;
int port;
std::string transport_type;
bool secure;
};
// STUN server address and port.
std::string stun_server;
int stun_server_port;
std::vector<RelayServerConfig> relays;
bool legacy_relay;
// Disable TCP-based transport when set to true.
bool disable_tcp_transport;
};
P2PPortAllocator(blink::WebFrame* web_frame,
P2PSocketDispatcher* socket_dispatcher,
talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory,
const Config& config);
virtual ~P2PPortAllocator();
virtual cricket::PortAllocatorSession* CreateSessionInternal(
const std::string& content_name,
int component,
const std::string& ice_username_fragment,
const std::string& ice_password) OVERRIDE;
private:
friend class P2PPortAllocatorSession;
blink::WebFrame* web_frame_;
P2PSocketDispatcher* socket_dispatcher_;
Config config_;
DISALLOW_COPY_AND_ASSIGN(P2PPortAllocator);
};
class P2PPortAllocatorSession : public cricket::BasicPortAllocatorSession,
public blink::WebURLLoaderClient {
public:
P2PPortAllocatorSession(
P2PPortAllocator* allocator,
const std::string& content_name,
int component,
const std::string& ice_username_fragment,
const std::string& ice_password);
virtual ~P2PPortAllocatorSession();
// blink::WebURLLoaderClient overrides.
virtual void didReceiveData(blink::WebURLLoader* loader,
const char* data,
int data_length,
int encoded_data_length) OVERRIDE;
virtual void didFinishLoading(blink::WebURLLoader* loader,
double finish_time) OVERRIDE;
virtual void didFail(blink::WebURLLoader* loader,
const blink::WebURLError& error) OVERRIDE;
protected:
// Overrides for cricket::BasicPortAllocatorSession.
virtual void GetPortConfigurations() OVERRIDE;
private:
struct RelayServer {
RelayServer();
~RelayServer();
P2PPortAllocator::Config::RelayServerConfig config;
talk_base::SocketAddress resolved_relay_address;
scoped_refptr<P2PHostAddressRequest> relay_address_request;
};
void ResolveStunServerAddress();
void OnStunServerAddress(const net::IPAddressNumber& address);
void ResolveRelayServerAddresses();
void OnRelayServerAddressResolved(size_t index,
const net::IPAddressNumber& address);
bool IsRelayAddressesResolved() const;
// This method allocates non-TURN relay sessions.
void AllocateLegacyRelaySession();
void ParseRelayResponse();
void AddConfig();
P2PPortAllocator* allocator_;
scoped_refptr<P2PHostAddressRequest> stun_address_request_;
talk_base::SocketAddress stun_server_address_;
std::vector<RelayServer> relay_info_;
scoped_ptr<blink::WebURLLoader> relay_session_request_;
int relay_session_attempts_;
std::string relay_session_response_;
talk_base::SocketAddress relay_ip_;
int relay_udp_port_;
int relay_tcp_port_;
int relay_ssltcp_port_;
int pending_relay_requests_;
DISALLOW_COPY_AND_ASSIGN(P2PPortAllocatorSession);
};
} // namespace content
#endif // CONTENT_RENDERER_P2P_PORT_ALLOCATOR_H_
|
