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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
// 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_MEDIA_RTC_PEER_CONNECTION_HANDLER_H_
#define CONTENT_RENDERER_MEDIA_RTC_PEER_CONNECTION_HANDLER_H_
#include <map>
#include <string>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "content/common/content_export.h"
#include "content/renderer/media/webrtc/media_stream_track_metrics.h"
#include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandler.h"
#include "third_party/WebKit/public/platform/WebRTCStatsRequest.h"
#include "third_party/WebKit/public/platform/WebRTCStatsResponse.h"
namespace blink {
class WebFrame;
class WebRTCDataChannelHandler;
class WebRTCOfferOptions;
}
namespace content {
class PeerConnectionDependencyFactory;
class PeerConnectionTracker;
class RemoteMediaStreamImpl;
class RTCMediaConstraints;
class WebRtcMediaStreamAdapter;
// Mockable wrapper for blink::WebRTCStatsResponse
class CONTENT_EXPORT LocalRTCStatsResponse
: public NON_EXPORTED_BASE(rtc::RefCountInterface) {
public:
explicit LocalRTCStatsResponse(const blink::WebRTCStatsResponse& impl)
: impl_(impl) {
}
virtual blink::WebRTCStatsResponse webKitStatsResponse() const;
virtual size_t addReport(blink::WebString type, blink::WebString id,
double timestamp);
virtual void addStatistic(size_t report,
blink::WebString name, blink::WebString value);
protected:
virtual ~LocalRTCStatsResponse() {}
// Constructor for creating mocks.
LocalRTCStatsResponse() {}
private:
blink::WebRTCStatsResponse impl_;
};
// Mockable wrapper for blink::WebRTCStatsRequest
class CONTENT_EXPORT LocalRTCStatsRequest
: public NON_EXPORTED_BASE(rtc::RefCountInterface) {
public:
explicit LocalRTCStatsRequest(blink::WebRTCStatsRequest impl);
// Constructor for testing.
LocalRTCStatsRequest();
virtual bool hasSelector() const;
virtual blink::WebMediaStreamTrack component() const;
virtual void requestSucceeded(const LocalRTCStatsResponse* response);
virtual scoped_refptr<LocalRTCStatsResponse> createResponse();
protected:
virtual ~LocalRTCStatsRequest();
private:
blink::WebRTCStatsRequest impl_;
rtc::scoped_refptr<LocalRTCStatsResponse> response_;
};
// RTCPeerConnectionHandler is a delegate for the RTC PeerConnection API
// messages going between WebKit and native PeerConnection in libjingle. It's
// owned by WebKit.
// WebKit calls all of these methods on the main render thread.
// Callbacks to the webrtc::PeerConnectionObserver implementation also occur on
// the main render thread.
class CONTENT_EXPORT RTCPeerConnectionHandler
: NON_EXPORTED_BASE(public blink::WebRTCPeerConnectionHandler),
NON_EXPORTED_BASE(public webrtc::PeerConnectionObserver) {
public:
RTCPeerConnectionHandler(
blink::WebRTCPeerConnectionHandlerClient* client,
PeerConnectionDependencyFactory* dependency_factory);
virtual ~RTCPeerConnectionHandler();
// Destroy all existing RTCPeerConnectionHandler objects.
static void DestructAllHandlers();
static void ConvertOfferOptionsToConstraints(
const blink::WebRTCOfferOptions& options,
RTCMediaConstraints* output);
void associateWithFrame(blink::WebFrame* frame);
// Initialize method only used for unit test.
bool InitializeForTest(
const blink::WebRTCConfiguration& server_configuration,
const blink::WebMediaConstraints& options,
PeerConnectionTracker* peer_connection_tracker);
// blink::WebRTCPeerConnectionHandler implementation
virtual bool initialize(
const blink::WebRTCConfiguration& server_configuration,
const blink::WebMediaConstraints& options) OVERRIDE;
virtual void createOffer(
const blink::WebRTCSessionDescriptionRequest& request,
const blink::WebMediaConstraints& options) OVERRIDE;
virtual void createOffer(
const blink::WebRTCSessionDescriptionRequest& request,
const blink::WebRTCOfferOptions& options) OVERRIDE;
virtual void createAnswer(
const blink::WebRTCSessionDescriptionRequest& request,
const blink::WebMediaConstraints& options) OVERRIDE;
virtual void setLocalDescription(
const blink::WebRTCVoidRequest& request,
const blink::WebRTCSessionDescription& description) OVERRIDE;
virtual void setRemoteDescription(
const blink::WebRTCVoidRequest& request,
const blink::WebRTCSessionDescription& description) OVERRIDE;
virtual blink::WebRTCSessionDescription localDescription()
OVERRIDE;
virtual blink::WebRTCSessionDescription remoteDescription()
OVERRIDE;
virtual bool updateICE(
const blink::WebRTCConfiguration& server_configuration,
const blink::WebMediaConstraints& options) OVERRIDE;
virtual bool addICECandidate(
const blink::WebRTCICECandidate& candidate) OVERRIDE;
virtual bool addICECandidate(
const blink::WebRTCVoidRequest& request,
const blink::WebRTCICECandidate& candidate) OVERRIDE;
virtual void OnaddICECandidateResult(const blink::WebRTCVoidRequest& request,
bool result);
virtual bool addStream(
const blink::WebMediaStream& stream,
const blink::WebMediaConstraints& options) OVERRIDE;
virtual void removeStream(
const blink::WebMediaStream& stream) OVERRIDE;
virtual void getStats(
const blink::WebRTCStatsRequest& request) OVERRIDE;
virtual blink::WebRTCDataChannelHandler* createDataChannel(
const blink::WebString& label,
const blink::WebRTCDataChannelInit& init) OVERRIDE;
virtual blink::WebRTCDTMFSenderHandler* createDTMFSender(
const blink::WebMediaStreamTrack& track) OVERRIDE;
virtual void stop() OVERRIDE;
// webrtc::PeerConnectionObserver implementation
virtual void OnError() OVERRIDE;
// Triggered when the SignalingState changed.
virtual void OnSignalingChange(
webrtc::PeerConnectionInterface::SignalingState new_state) OVERRIDE;
virtual void OnAddStream(webrtc::MediaStreamInterface* stream) OVERRIDE;
virtual void OnRemoveStream(webrtc::MediaStreamInterface* stream) OVERRIDE;
virtual void OnIceCandidate(
const webrtc::IceCandidateInterface* candidate) OVERRIDE;
virtual void OnIceConnectionChange(
webrtc::PeerConnectionInterface::IceConnectionState new_state) OVERRIDE;
virtual void OnIceGatheringChange(
webrtc::PeerConnectionInterface::IceGatheringState new_state) OVERRIDE;
virtual void OnDataChannel(
webrtc::DataChannelInterface* data_channel) OVERRIDE;
virtual void OnRenegotiationNeeded() OVERRIDE;
// Delegate functions to allow for mocking of WebKit interfaces.
// getStats takes ownership of request parameter.
virtual void getStats(LocalRTCStatsRequest* request);
// Calls GetStats on |native_peer_connection_|.
void GetStats(webrtc::StatsObserver* observer,
webrtc::MediaStreamTrackInterface* track,
webrtc::PeerConnectionInterface::StatsOutputLevel level);
// Tells the |client_| to close RTCPeerConnection.
void CloseClientPeerConnection();
PeerConnectionTracker* peer_connection_tracker();
protected:
webrtc::PeerConnectionInterface* native_peer_connection() {
return native_peer_connection_.get();
}
private:
webrtc::SessionDescriptionInterface* CreateNativeSessionDescription(
const blink::WebRTCSessionDescription& description,
webrtc::SdpParseError* error);
// |client_| is a weak pointer, and is valid until stop() has returned.
blink::WebRTCPeerConnectionHandlerClient* client_;
// |dependency_factory_| is a raw pointer, and is valid for the lifetime of
// RenderThreadImpl.
PeerConnectionDependencyFactory* dependency_factory_;
blink::WebFrame* frame_;
ScopedVector<WebRtcMediaStreamAdapter> local_streams_;
PeerConnectionTracker* peer_connection_tracker_;
MediaStreamTrackMetrics track_metrics_;
// Counter for a UMA stat reported at destruction time.
int num_data_channels_created_;
// Counter for number of IPv4 and IPv6 local candidates.
int num_local_candidates_ipv4_;
int num_local_candidates_ipv6_;
// |native_peer_connection_| is the libjingle native PeerConnection object.
scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection_;
typedef std::map<webrtc::MediaStreamInterface*,
content::RemoteMediaStreamImpl*> RemoteStreamMap;
RemoteStreamMap remote_streams_;
scoped_refptr<webrtc::UMAObserver> uma_observer_;
base::TimeTicks ice_connection_checking_start_;
DISALLOW_COPY_AND_ASSIGN(RTCPeerConnectionHandler);
};
} // namespace content
#endif // CONTENT_RENDERER_MEDIA_RTC_PEER_CONNECTION_HANDLER_H_
|
