OLD | NEW |
| (Empty) |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/shell/renderer/test_runner/MockWebRTCPeerConnectionHandler.h" | |
6 | |
7 #include "content/shell/renderer/test_runner/TestInterfaces.h" | |
8 #include "content/shell/renderer/test_runner/WebTestDelegate.h" | |
9 #include "content/shell/renderer/test_runner/mock_constraints.h" | |
10 #include "content/shell/renderer/test_runner/mock_webrtc_data_channel_handler.h" | |
11 #include "content/shell/renderer/test_runner/mock_webrtc_dtmf_sender_handler.h" | |
12 #include "third_party/WebKit/public/platform/WebMediaConstraints.h" | |
13 #include "third_party/WebKit/public/platform/WebMediaStream.h" | |
14 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" | |
15 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h" | |
16 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h
" | |
17 #include "third_party/WebKit/public/platform/WebRTCStatsResponse.h" | |
18 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h" | |
19 #include "third_party/WebKit/public/platform/WebString.h" | |
20 #include "third_party/WebKit/public/platform/WebVector.h" | |
21 | |
22 using namespace blink; | |
23 | |
24 namespace content { | |
25 | |
26 class RTCSessionDescriptionRequestSuccededTask : public WebMethodTask<MockWebRTC
PeerConnectionHandler> { | |
27 public: | |
28 RTCSessionDescriptionRequestSuccededTask(MockWebRTCPeerConnectionHandler* ob
ject, const WebRTCSessionDescriptionRequest& request, const WebRTCSessionDescrip
tion& result) | |
29 : WebMethodTask<MockWebRTCPeerConnectionHandler>(object) | |
30 , m_request(request) | |
31 , m_result(result) | |
32 { | |
33 } | |
34 | |
35 virtual void runIfValid() OVERRIDE | |
36 { | |
37 m_request.requestSucceeded(m_result); | |
38 } | |
39 | |
40 private: | |
41 WebRTCSessionDescriptionRequest m_request; | |
42 WebRTCSessionDescription m_result; | |
43 }; | |
44 | |
45 class RTCSessionDescriptionRequestFailedTask : public WebMethodTask<MockWebRTCPe
erConnectionHandler> { | |
46 public: | |
47 RTCSessionDescriptionRequestFailedTask(MockWebRTCPeerConnectionHandler* obje
ct, const WebRTCSessionDescriptionRequest& request) | |
48 : WebMethodTask<MockWebRTCPeerConnectionHandler>(object) | |
49 , m_request(request) | |
50 { | |
51 } | |
52 | |
53 virtual void runIfValid() OVERRIDE | |
54 { | |
55 m_request.requestFailed("TEST_ERROR"); | |
56 } | |
57 | |
58 private: | |
59 WebRTCSessionDescriptionRequest m_request; | |
60 }; | |
61 | |
62 class RTCStatsRequestSucceededTask : public WebMethodTask<MockWebRTCPeerConnecti
onHandler> { | |
63 public: | |
64 RTCStatsRequestSucceededTask(MockWebRTCPeerConnectionHandler* object, const
blink::WebRTCStatsRequest& request, const blink::WebRTCStatsResponse& response) | |
65 : WebMethodTask<MockWebRTCPeerConnectionHandler>(object) | |
66 , m_request(request) | |
67 , m_response(response) | |
68 { | |
69 } | |
70 | |
71 virtual void runIfValid() OVERRIDE | |
72 { | |
73 m_request.requestSucceeded(m_response); | |
74 } | |
75 | |
76 private: | |
77 blink::WebRTCStatsRequest m_request; | |
78 blink::WebRTCStatsResponse m_response; | |
79 }; | |
80 | |
81 class RTCVoidRequestTask : public WebMethodTask<MockWebRTCPeerConnectionHandler>
{ | |
82 public: | |
83 RTCVoidRequestTask(MockWebRTCPeerConnectionHandler* object, const WebRTCVoid
Request& request, bool succeeded) | |
84 : WebMethodTask<MockWebRTCPeerConnectionHandler>(object) | |
85 , m_request(request) | |
86 , m_succeeded(succeeded) | |
87 { | |
88 } | |
89 | |
90 virtual void runIfValid() OVERRIDE | |
91 { | |
92 if (m_succeeded) | |
93 m_request.requestSucceeded(); | |
94 else | |
95 m_request.requestFailed("TEST_ERROR"); | |
96 } | |
97 | |
98 private: | |
99 WebRTCVoidRequest m_request; | |
100 bool m_succeeded; | |
101 }; | |
102 | |
103 class RTCPeerConnectionStateTask : public WebMethodTask<MockWebRTCPeerConnection
Handler> { | |
104 public: | |
105 RTCPeerConnectionStateTask(MockWebRTCPeerConnectionHandler* object, WebRTCPe
erConnectionHandlerClient* client, WebRTCPeerConnectionHandlerClient::ICEConnect
ionState connectionState, WebRTCPeerConnectionHandlerClient::ICEGatheringState g
atheringState) | |
106 : WebMethodTask<MockWebRTCPeerConnectionHandler>(object) | |
107 , m_client(client) | |
108 , m_connectionState(connectionState) | |
109 , m_gatheringState(gatheringState) | |
110 { | |
111 } | |
112 | |
113 virtual void runIfValid() OVERRIDE | |
114 { | |
115 m_client->didChangeICEGatheringState(m_gatheringState); | |
116 m_client->didChangeICEConnectionState(m_connectionState); | |
117 } | |
118 | |
119 private: | |
120 WebRTCPeerConnectionHandlerClient* m_client; | |
121 WebRTCPeerConnectionHandlerClient::ICEConnectionState m_connectionState; | |
122 WebRTCPeerConnectionHandlerClient::ICEGatheringState m_gatheringState; | |
123 }; | |
124 | |
125 class RemoteDataChannelTask : public WebMethodTask<MockWebRTCPeerConnectionHandl
er> { | |
126 public: | |
127 RemoteDataChannelTask(MockWebRTCPeerConnectionHandler* object, WebRTCPeerCon
nectionHandlerClient* client, WebTestDelegate* delegate) | |
128 : WebMethodTask<MockWebRTCPeerConnectionHandler>(object) | |
129 , m_client(client) | |
130 , m_delegate(delegate) | |
131 { | |
132 } | |
133 | |
134 virtual void runIfValid() OVERRIDE | |
135 { | |
136 WebRTCDataChannelInit init; | |
137 WebRTCDataChannelHandler* remoteDataChannel = new MockWebRTCDataChannelH
andler("MockRemoteDataChannel", init, m_delegate); | |
138 m_client->didAddRemoteDataChannel(remoteDataChannel); | |
139 } | |
140 | |
141 private: | |
142 WebRTCPeerConnectionHandlerClient* m_client; | |
143 WebTestDelegate* m_delegate; | |
144 }; | |
145 | |
146 ///////////////////// | |
147 | |
148 MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler() | |
149 { | |
150 } | |
151 | |
152 MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler(WebRTCPeerConne
ctionHandlerClient* client, TestInterfaces* interfaces) | |
153 : m_client(client) | |
154 , m_stopped(false) | |
155 , m_streamCount(0) | |
156 , m_interfaces(interfaces) | |
157 { | |
158 } | |
159 | |
160 bool MockWebRTCPeerConnectionHandler::initialize(const WebRTCConfiguration&, con
st WebMediaConstraints& constraints) | |
161 { | |
162 if (MockConstraints::VerifyConstraints(constraints)) { | |
163 m_interfaces->delegate()->postTask(new RTCPeerConnectionStateTask(this,
m_client, WebRTCPeerConnectionHandlerClient::ICEConnectionStateCompleted, WebRTC
PeerConnectionHandlerClient::ICEGatheringStateComplete)); | |
164 return true; | |
165 } | |
166 | |
167 return false; | |
168 } | |
169 | |
170 void MockWebRTCPeerConnectionHandler::createOffer(const WebRTCSessionDescription
Request& request, const WebMediaConstraints& constraints) | |
171 { | |
172 WebString shouldSucceed; | |
173 if (constraints.getMandatoryConstraintValue("succeed", shouldSucceed) && sho
uldSucceed == "true") { | |
174 WebRTCSessionDescription sessionDescription; | |
175 sessionDescription.initialize("offer", "local"); | |
176 m_interfaces->delegate()->postTask(new RTCSessionDescriptionRequestSucce
dedTask(this, request, sessionDescription)); | |
177 } else | |
178 m_interfaces->delegate()->postTask(new RTCSessionDescriptionRequestFaile
dTask(this, request)); | |
179 } | |
180 | |
181 void MockWebRTCPeerConnectionHandler::createAnswer(const WebRTCSessionDescriptio
nRequest& request, const WebMediaConstraints&) | |
182 { | |
183 if (!m_remoteDescription.isNull()) { | |
184 WebRTCSessionDescription sessionDescription; | |
185 sessionDescription.initialize("answer", "local"); | |
186 m_interfaces->delegate()->postTask(new RTCSessionDescriptionRequestSucce
dedTask(this, request, sessionDescription)); | |
187 } else | |
188 m_interfaces->delegate()->postTask(new RTCSessionDescriptionRequestFaile
dTask(this, request)); | |
189 } | |
190 | |
191 void MockWebRTCPeerConnectionHandler::setLocalDescription(const WebRTCVoidReques
t& request, const WebRTCSessionDescription& localDescription) | |
192 { | |
193 if (!localDescription.isNull() && localDescription.sdp() == "local") { | |
194 m_localDescription = localDescription; | |
195 m_interfaces->delegate()->postTask(new RTCVoidRequestTask(this, request,
true)); | |
196 } else | |
197 m_interfaces->delegate()->postTask(new RTCVoidRequestTask(this, request,
false)); | |
198 } | |
199 | |
200 void MockWebRTCPeerConnectionHandler::setRemoteDescription(const WebRTCVoidReque
st& request, const WebRTCSessionDescription& remoteDescription) | |
201 { | |
202 if (!remoteDescription.isNull() && remoteDescription.sdp() == "remote") { | |
203 m_remoteDescription = remoteDescription; | |
204 m_interfaces->delegate()->postTask(new RTCVoidRequestTask(this, request,
true)); | |
205 } else | |
206 m_interfaces->delegate()->postTask(new RTCVoidRequestTask(this, request,
false)); | |
207 } | |
208 | |
209 WebRTCSessionDescription MockWebRTCPeerConnectionHandler::localDescription() | |
210 { | |
211 return m_localDescription; | |
212 } | |
213 | |
214 WebRTCSessionDescription MockWebRTCPeerConnectionHandler::remoteDescription() | |
215 { | |
216 return m_remoteDescription; | |
217 } | |
218 | |
219 bool MockWebRTCPeerConnectionHandler::updateICE(const WebRTCConfiguration&, cons
t WebMediaConstraints&) | |
220 { | |
221 return true; | |
222 } | |
223 | |
224 bool MockWebRTCPeerConnectionHandler::addICECandidate(const WebRTCICECandidate&
iceCandidate) | |
225 { | |
226 m_client->didGenerateICECandidate(iceCandidate); | |
227 return true; | |
228 } | |
229 | |
230 bool MockWebRTCPeerConnectionHandler::addICECandidate(const WebRTCVoidRequest& r
equest, const WebRTCICECandidate& iceCandidate) | |
231 { | |
232 m_interfaces->delegate()->postTask(new RTCVoidRequestTask(this, request, tru
e)); | |
233 return true; | |
234 } | |
235 | |
236 bool MockWebRTCPeerConnectionHandler::addStream(const WebMediaStream& stream, co
nst WebMediaConstraints&) | |
237 { | |
238 ++m_streamCount; | |
239 m_client->negotiationNeeded(); | |
240 return true; | |
241 } | |
242 | |
243 void MockWebRTCPeerConnectionHandler::removeStream(const WebMediaStream& stream) | |
244 { | |
245 --m_streamCount; | |
246 m_client->negotiationNeeded(); | |
247 } | |
248 | |
249 void MockWebRTCPeerConnectionHandler::getStats(const WebRTCStatsRequest& request
) | |
250 { | |
251 WebRTCStatsResponse response = request.createResponse(); | |
252 double currentDate = m_interfaces->delegate()->getCurrentTimeInMillisecond()
; | |
253 if (request.hasSelector()) { | |
254 // FIXME: There is no check that the fetched values are valid. | |
255 size_t reportIndex = response.addReport("Mock video", "ssrc", currentDat
e); | |
256 response.addStatistic(reportIndex, "type", "video"); | |
257 } else { | |
258 for (int i = 0; i < m_streamCount; ++i) { | |
259 size_t reportIndex = response.addReport("Mock audio", "ssrc", curren
tDate); | |
260 response.addStatistic(reportIndex, "type", "audio"); | |
261 reportIndex = response.addReport("Mock video", "ssrc", currentDate); | |
262 response.addStatistic(reportIndex, "type", "video"); | |
263 } | |
264 } | |
265 m_interfaces->delegate()->postTask(new RTCStatsRequestSucceededTask(this, re
quest, response)); | |
266 } | |
267 | |
268 WebRTCDataChannelHandler* MockWebRTCPeerConnectionHandler::createDataChannel(con
st WebString& label, const blink::WebRTCDataChannelInit& init) | |
269 { | |
270 m_interfaces->delegate()->postTask(new RemoteDataChannelTask(this, m_client,
m_interfaces->delegate())); | |
271 | |
272 return new MockWebRTCDataChannelHandler(label, init, m_interfaces->delegate(
)); | |
273 } | |
274 | |
275 WebRTCDTMFSenderHandler* MockWebRTCPeerConnectionHandler::createDTMFSender(const
WebMediaStreamTrack& track) | |
276 { | |
277 return new MockWebRTCDTMFSenderHandler(track, m_interfaces->delegate()); | |
278 } | |
279 | |
280 void MockWebRTCPeerConnectionHandler::stop() | |
281 { | |
282 m_stopped = true; | |
283 } | |
284 | |
285 } // namespace content | |
OLD | NEW |