OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include <memory> | 8 #include <memory> |
9 #include <string> | 9 #include <string> |
10 #include <utility> | 10 #include <utility> |
11 | 11 |
12 #include "base/bind.h" | 12 #include "base/bind.h" |
13 #include "base/bind_helpers.h" | 13 #include "base/bind_helpers.h" |
14 #include "base/macros.h" | 14 #include "base/macros.h" |
15 #include "base/memory/ptr_util.h" | 15 #include "base/memory/ptr_util.h" |
16 #include "base/memory/ref_counted.h" | 16 #include "base/memory/ref_counted.h" |
17 #include "base/run_loop.h" | 17 #include "base/run_loop.h" |
18 #include "base/synchronization/waitable_event.h" | 18 #include "base/synchronization/waitable_event.h" |
19 #include "base/test/histogram_tester.h" | 19 #include "base/test/histogram_tester.h" |
20 #include "base/threading/thread_task_runner_handle.h" | 20 #include "base/threading/thread_task_runner_handle.h" |
21 #include "chrome/browser/media/router/issue.h" | 21 #include "chrome/browser/media/router/issue.h" |
22 #include "chrome/browser/media/router/media_route.h" | 22 #include "chrome/browser/media/router/media_route.h" |
23 #include "chrome/browser/media/router/media_source_helper.h" | 23 #include "chrome/browser/media/router/media_source_helper.h" |
24 #include "chrome/browser/media/router/mock_media_router.h" | 24 #include "chrome/browser/media/router/mock_media_router.h" |
25 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h" | 25 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h" |
26 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h" | 26 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h" |
27 #include "chrome/browser/media/router/mojo/media_router_type_converters.h" | |
28 #include "chrome/browser/media/router/route_message.h" | 27 #include "chrome/browser/media/router/route_message.h" |
29 #include "chrome/browser/media/router/route_message_observer.h" | 28 #include "chrome/browser/media/router/route_message_observer.h" |
30 #include "chrome/browser/media/router/test_helper.h" | 29 #include "chrome/browser/media/router/test_helper.h" |
31 #include "chrome/test/base/chrome_render_view_host_test_harness.h" | 30 #include "chrome/test/base/chrome_render_view_host_test_harness.h" |
32 #include "chrome/test/base/testing_browser_process.h" | 31 #include "chrome/test/base/testing_browser_process.h" |
33 #include "chrome/test/base/testing_profile.h" | 32 #include "chrome/test/base/testing_profile.h" |
34 #include "components/version_info/version_info.h" | 33 #include "components/version_info/version_info.h" |
35 #include "content/public/test/test_browser_thread_bundle.h" | 34 #include "content/public/test/test_browser_thread_bundle.h" |
36 #include "extensions/browser/extension_registry.h" | 35 #include "extensions/browser/extension_registry.h" |
37 #include "extensions/browser/process_manager.h" | 36 #include "extensions/browser/process_manager.h" |
(...skipping 14 matching lines...) Expand all Loading... | |
52 using testing::IsEmpty; | 51 using testing::IsEmpty; |
53 using testing::Mock; | 52 using testing::Mock; |
54 using testing::Not; | 53 using testing::Not; |
55 using testing::Pointee; | 54 using testing::Pointee; |
56 using testing::Return; | 55 using testing::Return; |
57 using testing::ReturnRef; | 56 using testing::ReturnRef; |
58 using testing::SaveArg; | 57 using testing::SaveArg; |
59 | 58 |
60 namespace media_router { | 59 namespace media_router { |
61 | 60 |
62 using PresentationConnectionState = | |
63 mojom::MediaRouter::PresentationConnectionState; | |
64 using PresentationConnectionCloseReason = | |
65 mojom::MediaRouter::PresentationConnectionCloseReason; | |
66 | |
67 namespace { | 61 namespace { |
68 | 62 |
69 const char kDescription[] = "description"; | 63 const char kDescription[] = "description"; |
70 const char kError[] = "error"; | 64 const char kError[] = "error"; |
71 const char kMessage[] = "message"; | 65 const char kMessage[] = "message"; |
72 const char kSource[] = "source1"; | 66 const char kSource[] = "source1"; |
73 const char kSource2[] = "source2"; | 67 const char kSource2[] = "source2"; |
74 const char kRouteId[] = "routeId"; | 68 const char kRouteId[] = "routeId"; |
75 const char kRouteId2[] = "routeId2"; | 69 const char kRouteId2[] = "routeId2"; |
76 const char kJoinableRouteId[] = "joinableRouteId"; | 70 const char kJoinableRouteId[] = "joinableRouteId"; |
77 const char kJoinableRouteId2[] = "joinableRouteId2"; | 71 const char kJoinableRouteId2[] = "joinableRouteId2"; |
78 const char kSinkId[] = "sink"; | 72 const char kSinkId[] = "sink"; |
79 const char kSinkId2[] = "sink2"; | 73 const char kSinkId2[] = "sink2"; |
80 const char kSinkName[] = "sinkName"; | 74 const char kSinkName[] = "sinkName"; |
81 const char kPresentationId[] = "presentationId"; | 75 const char kPresentationId[] = "presentationId"; |
82 const char kOrigin[] = "http://origin/"; | 76 const char kOrigin[] = "http://origin/"; |
83 const int kInvalidTabId = -1; | 77 const int kInvalidTabId = -1; |
84 const uint8_t kBinaryMessage[] = {0x01, 0x02, 0x03, 0x04}; | 78 const uint8_t kBinaryMessage[] = {0x01, 0x02, 0x03, 0x04}; |
85 const int kTimeoutMillis = 5 * 1000; | 79 const int kTimeoutMillis = 5 * 1000; |
86 | 80 |
87 IssueInfo CreateIssueInfo(const std::string& title) { | 81 IssueInfo CreateIssueInfo(const std::string& title) { |
88 IssueInfo issue_info; | 82 IssueInfo issue_info; |
89 issue_info.title = title; | 83 issue_info.title = title; |
90 issue_info.message = std::string("msg"); | 84 issue_info.message = std::string("msg"); |
91 issue_info.default_action = IssueInfo::Action::DISMISS; | 85 issue_info.default_action = IssueInfo::Action::DISMISS; |
92 issue_info.severity = IssueInfo::Severity::WARNING; | 86 issue_info.severity = IssueInfo::Severity::WARNING; |
93 return issue_info; | 87 return issue_info; |
94 } | 88 } |
95 | 89 |
96 mojom::MediaRoutePtr CreateMojoRoute() { | 90 MediaRoute CreateMediaRoute() { |
97 mojom::MediaRoutePtr route = mojom::MediaRoute::New(); | 91 return MediaRoute(kRouteId, MediaSource(kSource), kSinkId, kDescription, true, |
98 route->media_source = std::string(kSource); | 92 std::string(), true); |
99 route->media_sink_id = kSinkId; | |
100 route->media_route_id = kRouteId; | |
101 route->description = kDescription; | |
102 route->is_local = true; | |
103 route->for_display = true; | |
104 route->is_incognito = false; | |
105 return route; | |
106 } | 93 } |
107 | 94 |
108 } // namespace | 95 } // namespace |
109 | 96 |
110 class RouteResponseCallbackHandler { | 97 class RouteResponseCallbackHandler { |
111 public: | 98 public: |
112 void Invoke(const RouteRequestResult& result) { | 99 void Invoke(const RouteRequestResult& result) { |
113 DoInvoke(result.route(), result.presentation_id(), result.error(), | 100 DoInvoke(result.route(), result.presentation_id(), result.error(), |
114 result.result_code()); | 101 result.result_code()); |
115 } | 102 } |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
195 // a limitation with GMock::Invoke that prevents it from using move-only types | 182 // a limitation with GMock::Invoke that prevents it from using move-only types |
196 // in runnable parameter lists. | 183 // in runnable parameter lists. |
197 EXPECT_CALL(mock_media_route_provider_, | 184 EXPECT_CALL(mock_media_route_provider_, |
198 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), | 185 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), |
199 kInvalidTabId, _, _, _)) | 186 kInvalidTabId, _, _, _)) |
200 .WillOnce(Invoke( | 187 .WillOnce(Invoke( |
201 [](const std::string& source, const std::string& sink, | 188 [](const std::string& source, const std::string& sink, |
202 const std::string& presentation_id, const url::Origin& origin, | 189 const std::string& presentation_id, const url::Origin& origin, |
203 int tab_id, base::TimeDelta timeout, bool incognito, | 190 int tab_id, base::TimeDelta timeout, bool incognito, |
204 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { | 191 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { |
205 cb.Run(CreateMojoRoute(), std::string(), | 192 cb.Run(CreateMediaRoute(), std::string(), RouteRequestResult::OK); |
206 mojom::RouteRequestResultCode::OK); | |
207 })); | 193 })); |
208 | 194 |
209 base::RunLoop run_loop; | 195 base::RunLoop run_loop; |
210 RouteResponseCallbackHandler handler; | 196 RouteResponseCallbackHandler handler; |
211 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", | 197 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", |
212 RouteRequestResult::OK)) | 198 RouteRequestResult::OK)) |
213 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 199 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
214 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 200 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
215 route_response_callbacks.push_back(base::Bind( | 201 route_response_callbacks.push_back(base::Bind( |
216 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 202 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
217 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, | 203 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, |
218 route_response_callbacks, | 204 route_response_callbacks, |
219 base::TimeDelta::FromMilliseconds(kTimeoutMillis), | 205 base::TimeDelta::FromMilliseconds(kTimeoutMillis), |
220 false); | 206 false); |
221 run_loop.Run(); | 207 run_loop.Run(); |
222 ExpectResultBucketCount("CreateRoute", RouteRequestResult::ResultCode::OK, 1); | 208 ExpectResultBucketCount("CreateRoute", RouteRequestResult::OK, 1); |
223 } | 209 } |
224 | 210 |
225 TEST_F(MediaRouterMojoImplTest, CreateIncognitoRoute) { | 211 TEST_F(MediaRouterMojoImplTest, CreateIncognitoRoute) { |
226 MediaSource media_source(kSource); | 212 MediaSource media_source(kSource); |
227 MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "", | 213 MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "", |
228 false); | 214 false); |
229 expected_route.set_incognito(true); | 215 expected_route.set_incognito(true); |
230 | 216 |
231 // Use a lambda function as an invocation target here to work around | 217 // Use a lambda function as an invocation target here to work around |
232 // a limitation with GMock::Invoke that prevents it from using move-only types | 218 // a limitation with GMock::Invoke that prevents it from using move-only types |
233 // in runnable parameter lists. | 219 // in runnable parameter lists. |
234 EXPECT_CALL(mock_media_route_provider_, | 220 EXPECT_CALL(mock_media_route_provider_, |
235 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), | 221 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), |
236 kInvalidTabId, _, _, _)) | 222 kInvalidTabId, _, _, _)) |
237 .WillOnce(Invoke( | 223 .WillOnce(Invoke([&expected_route]( |
238 [](const std::string& source, const std::string& sink, | 224 const std::string& source, const std::string& sink, |
239 const std::string& presentation_id, const url::Origin& origin, | 225 const std::string& presentation_id, const url::Origin& origin, |
240 int tab_id, base::TimeDelta timeout, bool incognito, | 226 int tab_id, base::TimeDelta timeout, bool incognito, |
241 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { | 227 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { |
242 mojom::MediaRoutePtr route = CreateMojoRoute(); | 228 cb.Run(expected_route, std::string(), RouteRequestResult::OK); |
243 route->custom_controller_path = | 229 })); |
244 std::string("custom/controller/path"); | |
245 route->is_incognito = true; | |
246 cb.Run(std::move(route), std::string(), | |
247 mojom::RouteRequestResultCode::OK); | |
248 })); | |
249 | 230 |
250 base::RunLoop run_loop; | 231 base::RunLoop run_loop; |
251 RouteResponseCallbackHandler handler; | 232 RouteResponseCallbackHandler handler; |
252 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", | 233 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", |
253 RouteRequestResult::OK)) | 234 RouteRequestResult::OK)) |
254 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 235 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
255 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 236 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
256 route_response_callbacks.push_back(base::Bind( | 237 route_response_callbacks.push_back(base::Bind( |
257 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 238 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
258 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, | 239 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, |
259 route_response_callbacks, | 240 route_response_callbacks, |
260 base::TimeDelta::FromMilliseconds(kTimeoutMillis), | 241 base::TimeDelta::FromMilliseconds(kTimeoutMillis), |
261 true); | 242 true); |
262 run_loop.Run(); | 243 run_loop.Run(); |
263 ExpectResultBucketCount("CreateRoute", RouteRequestResult::ResultCode::OK, 1); | 244 ExpectResultBucketCount("CreateRoute", RouteRequestResult::OK, 1); |
264 } | 245 } |
265 | 246 |
266 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) { | 247 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) { |
267 EXPECT_CALL( | 248 EXPECT_CALL( |
268 mock_media_route_provider_, | 249 mock_media_route_provider_, |
269 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), | 250 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), |
270 kInvalidTabId, | 251 kInvalidTabId, |
271 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _)) | 252 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _)) |
272 .WillOnce(Invoke( | 253 .WillOnce(Invoke( |
273 [](const std::string& source, const std::string& sink, | 254 [](const std::string& source, const std::string& sink, |
274 const std::string& presentation_id, const url::Origin& origin, | 255 const std::string& presentation_id, const url::Origin& origin, |
275 int tab_id, base::TimeDelta timeout, bool incognito, | 256 int tab_id, base::TimeDelta timeout, bool incognito, |
276 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { | 257 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { |
277 cb.Run(mojom::MediaRoutePtr(), std::string(kError), | 258 cb.Run(base::nullopt, std::string(kError), |
278 mojom::RouteRequestResultCode::TIMED_OUT); | 259 RouteRequestResult::TIMED_OUT); |
279 })); | 260 })); |
280 | 261 |
281 RouteResponseCallbackHandler handler; | 262 RouteResponseCallbackHandler handler; |
282 base::RunLoop run_loop; | 263 base::RunLoop run_loop; |
283 EXPECT_CALL(handler, | 264 EXPECT_CALL(handler, |
284 DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT)) | 265 DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT)) |
285 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 266 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
286 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 267 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
287 route_response_callbacks.push_back(base::Bind( | 268 route_response_callbacks.push_back(base::Bind( |
288 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 269 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
289 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, | 270 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, |
290 route_response_callbacks, | 271 route_response_callbacks, |
291 base::TimeDelta::FromMilliseconds(kTimeoutMillis), | 272 base::TimeDelta::FromMilliseconds(kTimeoutMillis), |
292 false); | 273 false); |
293 run_loop.Run(); | 274 run_loop.Run(); |
294 ExpectResultBucketCount("CreateRoute", | 275 ExpectResultBucketCount("CreateRoute", RouteRequestResult::TIMED_OUT, 1); |
295 RouteRequestResult::ResultCode::TIMED_OUT, 1); | |
296 } | 276 } |
297 | 277 |
298 TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) { | 278 TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) { |
299 EXPECT_CALL( | 279 EXPECT_CALL( |
300 mock_media_route_provider_, | 280 mock_media_route_provider_, |
301 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), | 281 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), |
302 kInvalidTabId, | 282 kInvalidTabId, |
303 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) | 283 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) |
304 .WillOnce(Invoke( | 284 .WillOnce(Invoke( |
305 [](const std::string& source, const std::string& sink, | 285 [](const std::string& source, const std::string& sink, |
306 const std::string& presentation_id, const url::Origin& origin, | 286 const std::string& presentation_id, const url::Origin& origin, |
307 int tab_id, base::TimeDelta timeout, bool incognito, | 287 int tab_id, base::TimeDelta timeout, bool incognito, |
308 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { | 288 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { |
mark a. foltz
2017/02/09 22:53:52
Can this callback be typemapped? Same comment app
| |
309 cb.Run(CreateMojoRoute(), std::string(), | 289 cb.Run(CreateMediaRoute(), std::string(), RouteRequestResult::OK); |
310 mojom::RouteRequestResultCode::OK); | |
311 })); | 290 })); |
312 | 291 |
313 RouteResponseCallbackHandler handler; | 292 RouteResponseCallbackHandler handler; |
314 base::RunLoop run_loop; | 293 base::RunLoop run_loop; |
315 std::string error("Mismatch in incognito status: request = 1, response = 0"); | 294 std::string error("Mismatch in incognito status: request = 1, response = 0"); |
316 EXPECT_CALL(handler, DoInvoke(nullptr, "", error, | 295 EXPECT_CALL(handler, DoInvoke(nullptr, "", error, |
317 RouteRequestResult::INCOGNITO_MISMATCH)) | 296 RouteRequestResult::INCOGNITO_MISMATCH)) |
318 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 297 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
319 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 298 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
320 route_response_callbacks.push_back(base::Bind( | 299 route_response_callbacks.push_back(base::Bind( |
321 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 300 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
322 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, | 301 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, |
323 route_response_callbacks, | 302 route_response_callbacks, |
324 base::TimeDelta::FromMilliseconds(kTimeoutMillis), | 303 base::TimeDelta::FromMilliseconds(kTimeoutMillis), |
325 true); | 304 true); |
326 run_loop.Run(); | 305 run_loop.Run(); |
327 ExpectResultBucketCount( | 306 ExpectResultBucketCount("CreateRoute", RouteRequestResult::INCOGNITO_MISMATCH, |
328 "CreateRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1); | 307 1); |
329 } | 308 } |
330 | 309 |
331 TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) { | 310 TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) { |
332 mojom::MediaRoutePtr route = CreateMojoRoute(); | 311 MediaRoute route = CreateMediaRoute(); |
333 route->is_incognito = true; | 312 route.set_incognito(true); |
334 | 313 |
335 EXPECT_CALL( | 314 EXPECT_CALL( |
336 mock_media_route_provider_, | 315 mock_media_route_provider_, |
337 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), | 316 CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)), |
338 kInvalidTabId, | 317 kInvalidTabId, |
339 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) | 318 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) |
340 .WillOnce(Invoke( | 319 .WillOnce(Invoke([&route]( |
341 [](const std::string& source, const std::string& sink, | 320 const std::string& source, const std::string& sink, |
342 const std::string& presentation_id, const url::Origin& origin, | 321 const std::string& presentation_id, const url::Origin& origin, |
343 int tab_id, base::TimeDelta timeout, bool incognito, | 322 int tab_id, base::TimeDelta timeout, bool incognito, |
344 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { | 323 const mojom::MediaRouteProvider::CreateRouteCallback& cb) { |
345 mojom::MediaRoutePtr route = CreateMojoRoute(); | 324 cb.Run(route, std::string(), RouteRequestResult::OK); |
346 route->is_incognito = true; | 325 })); |
347 cb.Run(std::move(route), std::string(), | |
348 mojom::RouteRequestResultCode::OK); | |
349 })); | |
350 base::RunLoop run_loop; | 326 base::RunLoop run_loop; |
351 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, | 327 router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr, |
352 std::vector<MediaRouteResponseCallback>(), | 328 std::vector<MediaRouteResponseCallback>(), |
353 base::TimeDelta::FromMilliseconds(kTimeoutMillis), | 329 base::TimeDelta::FromMilliseconds(kTimeoutMillis), |
354 true); | 330 true); |
355 std::vector<mojom::MediaRoutePtr> mojo_routes(1); | 331 std::vector<MediaRoute> routes; |
mark a. foltz
2017/02/09 22:53:52
routes({route}). Or just create the vector in the
| |
356 mojo_routes[0] = route->Clone(); | 332 routes.push_back(route); |
357 router()->OnRoutesUpdated(std::move(mojo_routes), std::string(), | 333 router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>()); |
358 std::vector<std::string>()); | |
359 | 334 |
360 // TODO(mfoltz): Where possible, convert other tests to use RunUntilIdle | 335 // TODO(mfoltz): Where possible, convert other tests to use RunUntilIdle |
361 // instead of manually calling Run/Quit on the run loop. | 336 // instead of manually calling Run/Quit on the run loop. |
362 run_loop.RunUntilIdle(); | 337 run_loop.RunUntilIdle(); |
363 | 338 |
364 EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _)) | 339 EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _)) |
365 .WillOnce(Invoke([]( | 340 .WillOnce(Invoke( |
366 const std::string& route_id, | 341 [](const std::string& route_id, |
367 const mojom::MediaRouteProvider::TerminateRouteCallback& cb) { | 342 const mojom::MediaRouteProvider::TerminateRouteCallback& cb) { |
368 cb.Run(base::nullopt, mojom::RouteRequestResultCode::OK); | 343 cb.Run(base::nullopt, RouteRequestResult::OK); |
369 })); | 344 })); |
370 | 345 |
371 base::RunLoop run_loop2; | 346 base::RunLoop run_loop2; |
372 router()->OnIncognitoProfileShutdown(); | 347 router()->OnIncognitoProfileShutdown(); |
373 run_loop2.RunUntilIdle(); | 348 run_loop2.RunUntilIdle(); |
374 } | 349 } |
375 | 350 |
376 TEST_F(MediaRouterMojoImplTest, JoinRoute) { | 351 TEST_F(MediaRouterMojoImplTest, JoinRoute) { |
377 MediaSource media_source(kSource); | 352 MediaSource media_source(kSource); |
378 MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "", | 353 MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "", |
379 false); | 354 false); |
380 | 355 |
381 mojom::MediaRoutePtr route = CreateMojoRoute(); | 356 MediaRoute route = CreateMediaRoute(); |
382 // Make sure the MR has received an update with the route, so it knows there | 357 // Make sure the MR has received an update with the route, so it knows there |
383 // is a route to join. | 358 // is a route to join. |
384 std::vector<mojom::MediaRoutePtr> mojo_routes(1); | 359 std::vector<MediaRoute> routes; |
385 mojo_routes[0] = route->Clone(); | 360 routes.push_back(route); |
386 router()->OnRoutesUpdated(std::move(mojo_routes), std::string(), | 361 router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>()); |
387 std::vector<std::string>()); | |
388 EXPECT_TRUE(router()->HasJoinableRoute()); | 362 EXPECT_TRUE(router()->HasJoinableRoute()); |
389 | 363 |
390 // Use a lambda function as an invocation target here to work around | 364 // Use a lambda function as an invocation target here to work around |
391 // a limitation with GMock::Invoke that prevents it from using move-only types | 365 // a limitation with GMock::Invoke that prevents it from using move-only types |
392 // in runnable parameter lists. | 366 // in runnable parameter lists. |
393 EXPECT_CALL( | 367 EXPECT_CALL( |
394 mock_media_route_provider_, | 368 mock_media_route_provider_, |
395 JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 369 JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
396 kInvalidTabId, | 370 kInvalidTabId, |
397 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _)) | 371 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _)) |
398 .WillOnce(Invoke([&route]( | 372 .WillOnce(Invoke([&route]( |
399 const std::string& source, const std::string& presentation_id, | 373 const std::string& source, const std::string& presentation_id, |
400 const url::Origin& origin, int tab_id, base::TimeDelta timeout, | 374 const url::Origin& origin, int tab_id, base::TimeDelta timeout, |
401 bool incognito, | 375 bool incognito, |
402 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { | 376 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { |
403 cb.Run(std::move(route), std::string(), | 377 cb.Run(route, std::string(), RouteRequestResult::OK); |
404 mojom::RouteRequestResultCode::OK); | |
405 })); | 378 })); |
406 | 379 |
407 RouteResponseCallbackHandler handler; | 380 RouteResponseCallbackHandler handler; |
408 base::RunLoop run_loop; | 381 base::RunLoop run_loop; |
409 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", | 382 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", |
410 RouteRequestResult::OK)) | 383 RouteRequestResult::OK)) |
411 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 384 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
412 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 385 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
413 route_response_callbacks.push_back(base::Bind( | 386 route_response_callbacks.push_back(base::Bind( |
414 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 387 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
415 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 388 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
416 nullptr, route_response_callbacks, | 389 nullptr, route_response_callbacks, |
417 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); | 390 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); |
418 run_loop.Run(); | 391 run_loop.Run(); |
419 ExpectResultBucketCount("JoinRoute", RouteRequestResult::ResultCode::OK, 1); | 392 ExpectResultBucketCount("JoinRoute", RouteRequestResult::OK, 1); |
420 } | 393 } |
421 | 394 |
422 TEST_F(MediaRouterMojoImplTest, JoinRouteNotFoundFails) { | 395 TEST_F(MediaRouterMojoImplTest, JoinRouteNotFoundFails) { |
423 RouteResponseCallbackHandler handler; | 396 RouteResponseCallbackHandler handler; |
424 base::RunLoop run_loop; | 397 base::RunLoop run_loop; |
425 EXPECT_CALL(handler, DoInvoke(nullptr, "", "Route not found", | 398 EXPECT_CALL(handler, DoInvoke(nullptr, "", "Route not found", |
426 RouteRequestResult::ROUTE_NOT_FOUND)) | 399 RouteRequestResult::ROUTE_NOT_FOUND)) |
427 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 400 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
428 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 401 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
429 route_response_callbacks.push_back(base::Bind( | 402 route_response_callbacks.push_back(base::Bind( |
430 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 403 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
431 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 404 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
432 nullptr, route_response_callbacks, | 405 nullptr, route_response_callbacks, |
433 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); | 406 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); |
434 run_loop.Run(); | 407 run_loop.Run(); |
435 ExpectResultBucketCount("JoinRoute", | 408 ExpectResultBucketCount("JoinRoute", RouteRequestResult::ROUTE_NOT_FOUND, 1); |
436 RouteRequestResult::ResultCode::ROUTE_NOT_FOUND, 1); | |
437 } | 409 } |
438 | 410 |
439 TEST_F(MediaRouterMojoImplTest, JoinRouteTimedOutFails) { | 411 TEST_F(MediaRouterMojoImplTest, JoinRouteTimedOutFails) { |
440 // Make sure the MR has received an update with the route, so it knows there | 412 // Make sure the MR has received an update with the route, so it knows there |
441 // is a route to join. | 413 // is a route to join. |
442 std::vector<mojom::MediaRoutePtr> mojo_routes(1); | 414 std::vector<MediaRoute> routes; |
443 mojo_routes[0] = CreateMojoRoute(); | 415 routes.push_back(CreateMediaRoute()); |
444 router()->OnRoutesUpdated(std::move(mojo_routes), std::string(), | 416 router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>()); |
445 std::vector<std::string>()); | |
446 EXPECT_TRUE(router()->HasJoinableRoute()); | 417 EXPECT_TRUE(router()->HasJoinableRoute()); |
447 | 418 |
448 EXPECT_CALL( | 419 EXPECT_CALL( |
449 mock_media_route_provider_, | 420 mock_media_route_provider_, |
450 JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 421 JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
451 kInvalidTabId, | 422 kInvalidTabId, |
452 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _)) | 423 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _)) |
453 .WillOnce(Invoke( | 424 .WillOnce(Invoke( |
454 [](const std::string& source, const std::string& presentation_id, | 425 [](const std::string& source, const std::string& presentation_id, |
455 const url::Origin& origin, int tab_id, base::TimeDelta timeout, | 426 const url::Origin& origin, int tab_id, base::TimeDelta timeout, |
456 bool incognito, | 427 bool incognito, |
457 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { | 428 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { |
458 cb.Run(mojom::MediaRoutePtr(), std::string(kError), | 429 cb.Run(base::nullopt, std::string(kError), |
459 mojom::RouteRequestResultCode::TIMED_OUT); | 430 RouteRequestResult::TIMED_OUT); |
460 })); | 431 })); |
461 | 432 |
462 RouteResponseCallbackHandler handler; | 433 RouteResponseCallbackHandler handler; |
463 base::RunLoop run_loop; | 434 base::RunLoop run_loop; |
464 EXPECT_CALL(handler, | 435 EXPECT_CALL(handler, |
465 DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT)) | 436 DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT)) |
466 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 437 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
467 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 438 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
468 route_response_callbacks.push_back(base::Bind( | 439 route_response_callbacks.push_back(base::Bind( |
469 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 440 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
470 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 441 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
471 nullptr, route_response_callbacks, | 442 nullptr, route_response_callbacks, |
472 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); | 443 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); |
473 run_loop.Run(); | 444 run_loop.Run(); |
474 ExpectResultBucketCount("JoinRoute", | 445 ExpectResultBucketCount("JoinRoute", RouteRequestResult::TIMED_OUT, 1); |
475 RouteRequestResult::ResultCode::TIMED_OUT, 1); | |
476 } | 446 } |
477 | 447 |
478 TEST_F(MediaRouterMojoImplTest, JoinRouteIncognitoMismatchFails) { | 448 TEST_F(MediaRouterMojoImplTest, JoinRouteIncognitoMismatchFails) { |
479 mojom::MediaRoutePtr route = CreateMojoRoute(); | 449 MediaRoute route = CreateMediaRoute(); |
480 | 450 |
481 // Make sure the MR has received an update with the route, so it knows there | 451 // Make sure the MR has received an update with the route, so it knows there |
482 // is a route to join. | 452 // is a route to join. |
483 std::vector<mojom::MediaRoutePtr> mojo_routes(1); | 453 std::vector<MediaRoute> routes; |
484 mojo_routes[0] = route->Clone(); | 454 routes.push_back(route); |
485 router()->OnRoutesUpdated(std::move(mojo_routes), std::string(), | 455 router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>()); |
486 std::vector<std::string>()); | |
487 EXPECT_TRUE(router()->HasJoinableRoute()); | 456 EXPECT_TRUE(router()->HasJoinableRoute()); |
488 | 457 |
489 // Use a lambda function as an invocation target here to work around | 458 // Use a lambda function as an invocation target here to work around |
490 // a limitation with GMock::Invoke that prevents it from using move-only types | 459 // a limitation with GMock::Invoke that prevents it from using move-only types |
491 // in runnable parameter lists. | 460 // in runnable parameter lists. |
492 EXPECT_CALL( | 461 EXPECT_CALL( |
493 mock_media_route_provider_, | 462 mock_media_route_provider_, |
494 JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 463 JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
495 kInvalidTabId, | 464 kInvalidTabId, |
496 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) | 465 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) |
497 .WillOnce(Invoke([&route]( | 466 .WillOnce(Invoke([&route]( |
498 const std::string& source, const std::string& presentation_id, | 467 const std::string& source, const std::string& presentation_id, |
499 const url::Origin& origin, int tab_id, base::TimeDelta timeout, | 468 const url::Origin& origin, int tab_id, base::TimeDelta timeout, |
500 bool incognito, | 469 bool incognito, |
501 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { | 470 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { |
502 cb.Run(std::move(route), std::string(), | 471 cb.Run(route, std::string(), RouteRequestResult::OK); |
503 mojom::RouteRequestResultCode::OK); | |
504 })); | 472 })); |
505 | 473 |
506 RouteResponseCallbackHandler handler; | 474 RouteResponseCallbackHandler handler; |
507 base::RunLoop run_loop; | 475 base::RunLoop run_loop; |
508 std::string error("Mismatch in incognito status: request = 1, response = 0"); | 476 std::string error("Mismatch in incognito status: request = 1, response = 0"); |
509 EXPECT_CALL(handler, DoInvoke(nullptr, "", error, | 477 EXPECT_CALL(handler, DoInvoke(nullptr, "", error, |
510 RouteRequestResult::INCOGNITO_MISMATCH)) | 478 RouteRequestResult::INCOGNITO_MISMATCH)) |
511 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 479 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
512 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 480 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
513 route_response_callbacks.push_back(base::Bind( | 481 route_response_callbacks.push_back(base::Bind( |
514 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 482 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
515 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), | 483 router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)), |
516 nullptr, route_response_callbacks, | 484 nullptr, route_response_callbacks, |
517 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true); | 485 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true); |
518 run_loop.Run(); | 486 run_loop.Run(); |
519 ExpectResultBucketCount( | 487 ExpectResultBucketCount("JoinRoute", RouteRequestResult::INCOGNITO_MISMATCH, |
520 "JoinRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1); | 488 1); |
521 } | 489 } |
522 | 490 |
523 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteId) { | 491 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteId) { |
524 MediaSource media_source(kSource); | 492 MediaSource media_source(kSource); |
525 MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "", | 493 MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "", |
526 false); | 494 false); |
527 expected_route.set_incognito(false); | 495 expected_route.set_incognito(false); |
528 mojom::MediaRoutePtr route = CreateMojoRoute(); | 496 MediaRoute route = CreateMediaRoute(); |
529 | 497 |
530 // Use a lambda function as an invocation target here to work around | 498 // Use a lambda function as an invocation target here to work around |
531 // a limitation with GMock::Invoke that prevents it from using move-only types | 499 // a limitation with GMock::Invoke that prevents it from using move-only types |
532 // in runnable parameter lists. | 500 // in runnable parameter lists. |
533 EXPECT_CALL( | 501 EXPECT_CALL( |
534 mock_media_route_provider_, | 502 mock_media_route_provider_, |
535 ConnectRouteByRouteId( | 503 ConnectRouteByRouteId( |
536 kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId, | 504 kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId, |
537 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false, _)) | 505 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false, _)) |
538 .WillOnce(Invoke([&route]( | 506 .WillOnce(Invoke([&route]( |
539 const std::string& source, const std::string& route_id, | 507 const std::string& source, const std::string& route_id, |
540 const std::string& presentation_id, const url::Origin& origin, | 508 const std::string& presentation_id, const url::Origin& origin, |
541 int tab_id, base::TimeDelta timeout, bool incognito, | 509 int tab_id, base::TimeDelta timeout, bool incognito, |
542 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { | 510 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { |
543 cb.Run(std::move(route), std::string(), | 511 cb.Run(route, std::string(), RouteRequestResult::OK); |
544 mojom::RouteRequestResultCode::OK); | |
545 })); | 512 })); |
546 | 513 |
547 RouteResponseCallbackHandler handler; | 514 RouteResponseCallbackHandler handler; |
548 base::RunLoop run_loop; | 515 base::RunLoop run_loop; |
549 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", | 516 EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "", |
550 RouteRequestResult::OK)) | 517 RouteRequestResult::OK)) |
551 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 518 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
552 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 519 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
553 route_response_callbacks.push_back(base::Bind( | 520 route_response_callbacks.push_back(base::Bind( |
554 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 521 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
555 router()->ConnectRouteByRouteId( | 522 router()->ConnectRouteByRouteId( |
556 kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr, | 523 kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr, |
557 route_response_callbacks, | 524 route_response_callbacks, |
558 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); | 525 base::TimeDelta::FromMilliseconds(kTimeoutMillis), false); |
559 run_loop.Run(); | 526 run_loop.Run(); |
560 ExpectResultBucketCount("JoinRoute", RouteRequestResult::ResultCode::OK, 1); | 527 ExpectResultBucketCount("JoinRoute", RouteRequestResult::OK, 1); |
561 } | 528 } |
562 | 529 |
563 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) { | 530 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) { |
564 EXPECT_CALL( | 531 EXPECT_CALL( |
565 mock_media_route_provider_, | 532 mock_media_route_provider_, |
566 ConnectRouteByRouteId( | 533 ConnectRouteByRouteId( |
567 kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId, | 534 kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId, |
568 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) | 535 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) |
569 .WillOnce(Invoke( | 536 .WillOnce(Invoke( |
570 [](const std::string& source, const std::string& route_id, | 537 [](const std::string& source, const std::string& route_id, |
571 const std::string& presentation_id, const url::Origin& origin, | 538 const std::string& presentation_id, const url::Origin& origin, |
572 int tab_id, base::TimeDelta timeout, bool incognito, | 539 int tab_id, base::TimeDelta timeout, bool incognito, |
573 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { | 540 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { |
574 cb.Run(mojom::MediaRoutePtr(), std::string(kError), | 541 cb.Run(base::nullopt, std::string(kError), |
575 mojom::RouteRequestResultCode::TIMED_OUT); | 542 RouteRequestResult::TIMED_OUT); |
576 })); | 543 })); |
577 | 544 |
578 RouteResponseCallbackHandler handler; | 545 RouteResponseCallbackHandler handler; |
579 base::RunLoop run_loop; | 546 base::RunLoop run_loop; |
580 EXPECT_CALL(handler, | 547 EXPECT_CALL(handler, |
581 DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT)) | 548 DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT)) |
582 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 549 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
583 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 550 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
584 route_response_callbacks.push_back(base::Bind( | 551 route_response_callbacks.push_back(base::Bind( |
585 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 552 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
586 router()->ConnectRouteByRouteId( | 553 router()->ConnectRouteByRouteId( |
587 kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr, | 554 kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr, |
588 route_response_callbacks, | 555 route_response_callbacks, |
589 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true); | 556 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true); |
590 run_loop.Run(); | 557 run_loop.Run(); |
591 ExpectResultBucketCount("JoinRoute", | 558 ExpectResultBucketCount("JoinRoute", RouteRequestResult::TIMED_OUT, 1); |
592 RouteRequestResult::ResultCode::TIMED_OUT, 1); | |
593 } | 559 } |
594 | 560 |
595 TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) { | 561 TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) { |
596 mojom::MediaRoutePtr route = CreateMojoRoute(); | 562 MediaRoute route = CreateMediaRoute(); |
597 | 563 |
598 // Use a lambda function as an invocation target here to work around | 564 // Use a lambda function as an invocation target here to work around |
599 // a limitation with GMock::Invoke that prevents it from using move-only types | 565 // a limitation with GMock::Invoke that prevents it from using move-only types |
600 // in runnable parameter lists. | 566 // in runnable parameter lists. |
601 EXPECT_CALL( | 567 EXPECT_CALL( |
602 mock_media_route_provider_, | 568 mock_media_route_provider_, |
603 ConnectRouteByRouteId( | 569 ConnectRouteByRouteId( |
604 kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId, | 570 kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId, |
605 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) | 571 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _)) |
606 .WillOnce(Invoke([&route]( | 572 .WillOnce(Invoke([&route]( |
607 const std::string& source, const std::string& route_id, | 573 const std::string& source, const std::string& route_id, |
608 const std::string& presentation_id, const url::Origin& origin, | 574 const std::string& presentation_id, const url::Origin& origin, |
609 int tab_id, base::TimeDelta timeout, bool incognito, | 575 int tab_id, base::TimeDelta timeout, bool incognito, |
610 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { | 576 const mojom::MediaRouteProvider::JoinRouteCallback& cb) { |
611 cb.Run(std::move(route), std::string(), | 577 cb.Run(route, std::string(), RouteRequestResult::OK); |
612 mojom::RouteRequestResultCode::OK); | |
613 })); | 578 })); |
614 | 579 |
615 RouteResponseCallbackHandler handler; | 580 RouteResponseCallbackHandler handler; |
616 base::RunLoop run_loop; | 581 base::RunLoop run_loop; |
617 std::string error("Mismatch in incognito status: request = 1, response = 0"); | 582 std::string error("Mismatch in incognito status: request = 1, response = 0"); |
618 EXPECT_CALL(handler, DoInvoke(nullptr, "", error, | 583 EXPECT_CALL(handler, DoInvoke(nullptr, "", error, |
619 RouteRequestResult::INCOGNITO_MISMATCH)) | 584 RouteRequestResult::INCOGNITO_MISMATCH)) |
620 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 585 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
621 std::vector<MediaRouteResponseCallback> route_response_callbacks; | 586 std::vector<MediaRouteResponseCallback> route_response_callbacks; |
622 route_response_callbacks.push_back(base::Bind( | 587 route_response_callbacks.push_back(base::Bind( |
623 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); | 588 &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler))); |
624 router()->ConnectRouteByRouteId( | 589 router()->ConnectRouteByRouteId( |
625 kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr, | 590 kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr, |
626 route_response_callbacks, | 591 route_response_callbacks, |
627 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true); | 592 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true); |
628 run_loop.Run(); | 593 run_loop.Run(); |
629 ExpectResultBucketCount( | 594 ExpectResultBucketCount("JoinRoute", RouteRequestResult::INCOGNITO_MISMATCH, |
630 "JoinRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1); | 595 1); |
631 } | 596 } |
632 | 597 |
633 TEST_F(MediaRouterMojoImplTest, DetachRoute) { | 598 TEST_F(MediaRouterMojoImplTest, DetachRoute) { |
634 base::RunLoop run_loop; | 599 base::RunLoop run_loop; |
635 EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId)) | 600 EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId)) |
636 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 601 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
637 router()->DetachRoute(kRouteId); | 602 router()->DetachRoute(kRouteId); |
638 run_loop.Run(); | 603 run_loop.Run(); |
639 } | 604 } |
640 | 605 |
641 TEST_F(MediaRouterMojoImplTest, TerminateRoute) { | 606 TEST_F(MediaRouterMojoImplTest, TerminateRoute) { |
642 base::RunLoop run_loop; | 607 base::RunLoop run_loop; |
643 EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _)) | 608 EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _)) |
644 .WillOnce(Invoke([]( | 609 .WillOnce(Invoke( |
645 const std::string& route_id, | 610 [](const std::string& route_id, |
646 const mojom::MediaRouteProvider::TerminateRouteCallback& cb) { | 611 const mojom::MediaRouteProvider::TerminateRouteCallback& cb) { |
647 cb.Run(base::nullopt, mojom::RouteRequestResultCode::OK); | 612 cb.Run(base::nullopt, RouteRequestResult::OK); |
648 })); | 613 })); |
649 router()->TerminateRoute(kRouteId); | 614 router()->TerminateRoute(kRouteId); |
650 run_loop.RunUntilIdle(); | 615 run_loop.RunUntilIdle(); |
651 ExpectResultBucketCount("TerminateRoute", | 616 ExpectResultBucketCount("TerminateRoute", RouteRequestResult::OK, 1); |
652 RouteRequestResult::ResultCode::OK, | |
653 1); | |
654 } | 617 } |
655 | 618 |
656 TEST_F(MediaRouterMojoImplTest, TerminateRouteFails) { | 619 TEST_F(MediaRouterMojoImplTest, TerminateRouteFails) { |
657 base::RunLoop run_loop; | 620 base::RunLoop run_loop; |
658 EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _)) | 621 EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _)) |
659 .WillOnce(Invoke([]( | 622 .WillOnce(Invoke( |
660 const std::string& route_id, | 623 [](const std::string& route_id, |
661 const mojom::MediaRouteProvider::TerminateRouteCallback& cb) { | 624 const mojom::MediaRouteProvider::TerminateRouteCallback& cb) { |
662 cb.Run(std::string("timed out"), | 625 cb.Run(std::string("timed out"), RouteRequestResult::TIMED_OUT); |
663 mojom::RouteRequestResultCode::TIMED_OUT); | 626 })); |
664 })); | |
665 router()->TerminateRoute(kRouteId); | 627 router()->TerminateRoute(kRouteId); |
666 run_loop.RunUntilIdle(); | 628 run_loop.RunUntilIdle(); |
667 ExpectResultBucketCount("TerminateRoute", | 629 ExpectResultBucketCount("TerminateRoute", RouteRequestResult::OK, 0); |
668 RouteRequestResult::ResultCode::OK, | 630 ExpectResultBucketCount("TerminateRoute", RouteRequestResult::TIMED_OUT, 1); |
669 0); | |
670 ExpectResultBucketCount("TerminateRoute", | |
671 RouteRequestResult::ResultCode::TIMED_OUT, | |
672 1); | |
673 } | 631 } |
674 | 632 |
675 TEST_F(MediaRouterMojoImplTest, HandleIssue) { | 633 TEST_F(MediaRouterMojoImplTest, HandleIssue) { |
676 MockIssuesObserver issue_observer1(router()); | 634 MockIssuesObserver issue_observer1(router()); |
677 MockIssuesObserver issue_observer2(router()); | 635 MockIssuesObserver issue_observer2(router()); |
678 issue_observer1.Init(); | 636 issue_observer1.Init(); |
679 issue_observer2.Init(); | 637 issue_observer2.Init(); |
680 | 638 |
681 IssueInfo issue_info = CreateIssueInfo("title 1"); | 639 IssueInfo issue_info = CreateIssueInfo("title 1"); |
682 | 640 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
730 url::Origin(GURL(kOrigin)))); | 688 url::Origin(GURL(kOrigin)))); |
731 EXPECT_TRUE(unrelated_sinks_observer->Init()); | 689 EXPECT_TRUE(unrelated_sinks_observer->Init()); |
732 ProcessEventLoop(); | 690 ProcessEventLoop(); |
733 | 691 |
734 std::vector<MediaSink> expected_sinks; | 692 std::vector<MediaSink> expected_sinks; |
735 expected_sinks.push_back( | 693 expected_sinks.push_back( |
736 MediaSink(kSinkId, kSinkName, MediaSink::IconType::CAST)); | 694 MediaSink(kSinkId, kSinkName, MediaSink::IconType::CAST)); |
737 expected_sinks.push_back( | 695 expected_sinks.push_back( |
738 MediaSink(kSinkId2, kSinkName, MediaSink::IconType::CAST)); | 696 MediaSink(kSinkId2, kSinkName, MediaSink::IconType::CAST)); |
739 | 697 |
740 std::vector<mojom::MediaSinkPtr> mojo_sinks(2); | |
741 mojo_sinks[0] = mojom::MediaSink::New(); | |
742 mojo_sinks[0]->sink_id = kSinkId; | |
743 mojo_sinks[0]->name = kSinkName; | |
744 mojo_sinks[0]->icon_type = | |
745 media_router::mojom::MediaSink::IconType::CAST; | |
746 mojo_sinks[1] = mojom::MediaSink::New(); | |
747 mojo_sinks[1]->sink_id = kSinkId2; | |
748 mojo_sinks[1]->name = kSinkName; | |
749 mojo_sinks[1]->icon_type = | |
750 media_router::mojom::MediaSink::IconType::CAST; | |
751 | |
752 base::RunLoop run_loop; | 698 base::RunLoop run_loop; |
753 EXPECT_CALL(*sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks))); | 699 EXPECT_CALL(*sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks))); |
754 EXPECT_CALL(*extra_sinks_observer, | 700 EXPECT_CALL(*extra_sinks_observer, |
755 OnSinksReceived(SequenceEquals(expected_sinks))) | 701 OnSinksReceived(SequenceEquals(expected_sinks))) |
756 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 702 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
757 media_router_proxy_->OnSinksReceived( | 703 media_router_proxy_->OnSinksReceived( |
758 media_source.id(), std::move(mojo_sinks), | 704 media_source.id(), expected_sinks, |
759 std::vector<url::Origin>(1, url::Origin(GURL(kOrigin)))); | 705 std::vector<url::Origin>(1, url::Origin(GURL(kOrigin)))); |
760 run_loop.Run(); | 706 run_loop.Run(); |
761 | 707 |
762 // Since the MediaRouterMojoImpl has already received results for | 708 // Since the MediaRouterMojoImpl has already received results for |
763 // |media_source|, return cached results to observers that are subsequently | 709 // |media_source|, return cached results to observers that are subsequently |
764 // registered. | 710 // registered. |
765 std::unique_ptr<MockMediaSinksObserver> cached_sinks_observer( | 711 std::unique_ptr<MockMediaSinksObserver> cached_sinks_observer( |
766 new MockMediaSinksObserver(router(), media_source, | 712 new MockMediaSinksObserver(router(), media_source, |
767 url::Origin(GURL(kOrigin)))); | 713 url::Origin(GURL(kOrigin)))); |
768 EXPECT_CALL(*cached_sinks_observer, | 714 EXPECT_CALL(*cached_sinks_observer, |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
885 expected_routes.push_back(MediaRoute(kRouteId, media_source, kSinkId, | 831 expected_routes.push_back(MediaRoute(kRouteId, media_source, kSinkId, |
886 kDescription, false, "", false)); | 832 kDescription, false, "", false)); |
887 MediaRoute incognito_expected_route(kRouteId2, media_source, kSinkId, | 833 MediaRoute incognito_expected_route(kRouteId2, media_source, kSinkId, |
888 kDescription, false, "", false); | 834 kDescription, false, "", false); |
889 incognito_expected_route.set_incognito(true); | 835 incognito_expected_route.set_incognito(true); |
890 expected_routes.push_back(incognito_expected_route); | 836 expected_routes.push_back(incognito_expected_route); |
891 std::vector<MediaRoute::Id> expected_joinable_route_ids; | 837 std::vector<MediaRoute::Id> expected_joinable_route_ids; |
892 expected_joinable_route_ids.push_back(kJoinableRouteId); | 838 expected_joinable_route_ids.push_back(kJoinableRouteId); |
893 expected_joinable_route_ids.push_back(kJoinableRouteId2); | 839 expected_joinable_route_ids.push_back(kJoinableRouteId2); |
894 | 840 |
895 std::vector<std::string> mojo_joinable_routes(2); | |
896 mojo_joinable_routes[0] = kJoinableRouteId; | |
897 mojo_joinable_routes[1] = kJoinableRouteId2; | |
898 | |
899 std::vector<mojom::MediaRoutePtr> mojo_routes(2); | |
900 mojo_routes[0] = CreateMojoRoute(); | |
901 mojo_routes[1] = CreateMojoRoute(); | |
902 mojo_routes[1]->media_route_id = kRouteId2; | |
903 mojo_routes[1]->is_incognito = true; | |
904 | |
905 EXPECT_CALL(routes_observer, OnRoutesUpdated(SequenceEquals(expected_routes), | 841 EXPECT_CALL(routes_observer, OnRoutesUpdated(SequenceEquals(expected_routes), |
906 expected_joinable_route_ids)); | 842 expected_joinable_route_ids)); |
907 EXPECT_CALL(extra_routes_observer, | 843 EXPECT_CALL(extra_routes_observer, |
908 OnRoutesUpdated(SequenceEquals(expected_routes), | 844 OnRoutesUpdated(SequenceEquals(expected_routes), |
909 expected_joinable_route_ids)); | 845 expected_joinable_route_ids)); |
910 EXPECT_CALL(different_routes_observer, | 846 EXPECT_CALL(different_routes_observer, |
911 OnRoutesUpdated(SequenceEquals(expected_routes), | 847 OnRoutesUpdated(SequenceEquals(expected_routes), |
912 expected_joinable_route_ids)) | 848 expected_joinable_route_ids)) |
913 .Times(0); | 849 .Times(0); |
914 media_router_proxy_->OnRoutesUpdated(std::move(mojo_routes), | 850 media_router_proxy_->OnRoutesUpdated(expected_routes, media_source.id(), |
915 media_source.id(), | 851 expected_joinable_route_ids); |
916 std::move(mojo_joinable_routes)); | |
917 ProcessEventLoop(); | 852 ProcessEventLoop(); |
918 | 853 |
919 EXPECT_CALL(mock_router, UnregisterMediaRoutesObserver(&routes_observer)); | 854 EXPECT_CALL(mock_router, UnregisterMediaRoutesObserver(&routes_observer)); |
920 EXPECT_CALL(mock_router, | 855 EXPECT_CALL(mock_router, |
921 UnregisterMediaRoutesObserver(&extra_routes_observer)); | 856 UnregisterMediaRoutesObserver(&extra_routes_observer)); |
922 EXPECT_CALL(mock_router, | 857 EXPECT_CALL(mock_router, |
923 UnregisterMediaRoutesObserver(&different_routes_observer)); | 858 UnregisterMediaRoutesObserver(&different_routes_observer)); |
924 router()->UnregisterMediaRoutesObserver(&routes_observer); | 859 router()->UnregisterMediaRoutesObserver(&routes_observer); |
925 router()->UnregisterMediaRoutesObserver(&extra_routes_observer); | 860 router()->UnregisterMediaRoutesObserver(&extra_routes_observer); |
926 router()->UnregisterMediaRoutesObserver(&different_routes_observer); | 861 router()->UnregisterMediaRoutesObserver(&different_routes_observer); |
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1111 base::RunLoop run_loop; | 1046 base::RunLoop run_loop; |
1112 content::PresentationConnectionStateChangeInfo closed_info( | 1047 content::PresentationConnectionStateChangeInfo closed_info( |
1113 content::PRESENTATION_CONNECTION_STATE_CLOSED); | 1048 content::PRESENTATION_CONNECTION_STATE_CLOSED); |
1114 closed_info.close_reason = | 1049 closed_info.close_reason = |
1115 content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY; | 1050 content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY; |
1116 closed_info.message = "Foo"; | 1051 closed_info.message = "Foo"; |
1117 | 1052 |
1118 EXPECT_CALL(callback, Run(StateChangeInfoEquals(closed_info))) | 1053 EXPECT_CALL(callback, Run(StateChangeInfoEquals(closed_info))) |
1119 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 1054 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
1120 media_router_proxy_->OnPresentationConnectionClosed( | 1055 media_router_proxy_->OnPresentationConnectionClosed( |
1121 route_id, PresentationConnectionCloseReason::WENT_AWAY, "Foo"); | 1056 route_id, content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY, |
1057 "Foo"); | |
1122 run_loop.Run(); | 1058 run_loop.Run(); |
1123 EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback)); | 1059 EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback)); |
1124 } | 1060 } |
1125 | 1061 |
1126 content::PresentationConnectionStateChangeInfo terminated_info( | 1062 content::PresentationConnectionStateChangeInfo terminated_info( |
1127 content::PRESENTATION_CONNECTION_STATE_TERMINATED); | 1063 content::PRESENTATION_CONNECTION_STATE_TERMINATED); |
1128 { | 1064 { |
1129 base::RunLoop run_loop; | 1065 base::RunLoop run_loop; |
1130 EXPECT_CALL(callback, Run(StateChangeInfoEquals(terminated_info))) | 1066 EXPECT_CALL(callback, Run(StateChangeInfoEquals(terminated_info))) |
1131 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 1067 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
1132 media_router_proxy_->OnPresentationConnectionStateChanged( | 1068 media_router_proxy_->OnPresentationConnectionStateChanged( |
1133 route_id, PresentationConnectionState::TERMINATED); | 1069 route_id, content::PRESENTATION_CONNECTION_STATE_TERMINATED); |
1134 run_loop.Run(); | 1070 run_loop.Run(); |
1135 | 1071 |
1136 EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback)); | 1072 EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback)); |
1137 } | 1073 } |
1138 } | 1074 } |
1139 | 1075 |
1140 TEST_F(MediaRouterMojoImplTest, | 1076 TEST_F(MediaRouterMojoImplTest, |
1141 PresentationConnectionStateChangedCallbackRemoved) { | 1077 PresentationConnectionStateChangedCallbackRemoved) { |
1142 MediaRoute::Id route_id("route-id"); | 1078 MediaRoute::Id route_id("route-id"); |
1143 MockPresentationConnectionStateChangedCallback callback; | 1079 MockPresentationConnectionStateChangedCallback callback; |
1144 std::unique_ptr<PresentationConnectionStateSubscription> subscription = | 1080 std::unique_ptr<PresentationConnectionStateSubscription> subscription = |
1145 router()->AddPresentationConnectionStateChangedCallback( | 1081 router()->AddPresentationConnectionStateChangedCallback( |
1146 route_id, | 1082 route_id, |
1147 base::Bind(&MockPresentationConnectionStateChangedCallback::Run, | 1083 base::Bind(&MockPresentationConnectionStateChangedCallback::Run, |
1148 base::Unretained(&callback))); | 1084 base::Unretained(&callback))); |
1149 | 1085 |
1150 // Callback has been removed, so we don't expect it to be called anymore. | 1086 // Callback has been removed, so we don't expect it to be called anymore. |
1151 subscription.reset(); | 1087 subscription.reset(); |
1152 EXPECT_TRUE(router()->presentation_connection_state_callbacks_.empty()); | 1088 EXPECT_TRUE(router()->presentation_connection_state_callbacks_.empty()); |
1153 | 1089 |
1154 EXPECT_CALL(callback, Run(_)).Times(0); | 1090 EXPECT_CALL(callback, Run(_)).Times(0); |
1155 media_router_proxy_->OnPresentationConnectionStateChanged( | 1091 media_router_proxy_->OnPresentationConnectionStateChanged( |
1156 route_id, PresentationConnectionState::TERMINATED); | 1092 route_id, content::PRESENTATION_CONNECTION_STATE_TERMINATED); |
1157 ProcessEventLoop(); | 1093 ProcessEventLoop(); |
1158 } | 1094 } |
1159 | 1095 |
1160 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) { | 1096 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) { |
1161 base::RunLoop run_loop; | 1097 base::RunLoop run_loop; |
1162 EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id())) | 1098 EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id())) |
1163 .Times(2) | 1099 .Times(2) |
1164 .WillRepeatedly(Return(true)); | 1100 .WillRepeatedly(Return(true)); |
1165 EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _)) | 1101 EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _)) |
1166 .Times(2) | 1102 .Times(2) |
(...skipping 412 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1579 EXPECT_CALL(mock_media_route_provider_, | 1515 EXPECT_CALL(mock_media_route_provider_, |
1580 UpdateMediaSinks(MediaSourceForDesktop().id())) | 1516 UpdateMediaSinks(MediaSourceForDesktop().id())) |
1581 .WillOnce(InvokeWithoutArgs([&run_loop2]() { | 1517 .WillOnce(InvokeWithoutArgs([&run_loop2]() { |
1582 run_loop2.Quit(); | 1518 run_loop2.Quit(); |
1583 })); | 1519 })); |
1584 | 1520 |
1585 run_loop2.Run(); | 1521 run_loop2.Run(); |
1586 } | 1522 } |
1587 | 1523 |
1588 } // namespace media_router | 1524 } // namespace media_router |
OLD | NEW |