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
|
// 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 "base/basictypes.h"
#include "base/compiler_specific.h"
#include "content/common/content_export.h"
#include "content/renderer/media/peer_connection_handler_base.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;
}
namespace content {
class PeerConnectionTracker;
// Mockable wrapper for blink::WebRTCStatsResponse
class CONTENT_EXPORT LocalRTCStatsResponse
: public NON_EXPORTED_BASE(talk_base::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(talk_base::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_;
talk_base::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
: public PeerConnectionHandlerBase,
NON_EXPORTED_BASE(public blink::WebRTCPeerConnectionHandler) {
public:
RTCPeerConnectionHandler(
blink::WebRTCPeerConnectionHandlerClient* client,
MediaStreamDependencyFactory* dependency_factory);
virtual ~RTCPeerConnectionHandler();
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 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);
PeerConnectionTracker* peer_connection_tracker();
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_;
blink::WebFrame* frame_;
PeerConnectionTracker* peer_connection_tracker_;
DISALLOW_COPY_AND_ASSIGN(RTCPeerConnectionHandler);
};
} // namespace content
#endif // CONTENT_RENDERER_MEDIA_RTC_PEER_CONNECTION_HANDLER_H_
|
