OLD | NEW |
| (Empty) |
1 // Copyright 2016 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 #ifndef CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_STRUCT_TRAITS_H_ | |
6 #define CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_STRUCT_TRAITS_H_ | |
7 | |
8 #include <string> | |
9 | |
10 #include "chrome/browser/media/router/discovery/media_sink_internal.h" | |
11 #include "chrome/browser/media/router/issue.h" | |
12 #include "chrome/browser/media/router/mojo/media_router.mojom.h" | |
13 #include "chrome/browser/media/router/route_request_result.h" | |
14 #include "mojo/common/common_custom_types_struct_traits.h" | |
15 | |
16 namespace mojo { | |
17 | |
18 // Issue | |
19 | |
20 template <> | |
21 struct EnumTraits<media_router::mojom::Issue::ActionType, | |
22 media_router::IssueInfo::Action> { | |
23 static media_router::mojom::Issue::ActionType ToMojom( | |
24 media_router::IssueInfo::Action action) { | |
25 switch (action) { | |
26 case media_router::IssueInfo::Action::DISMISS: | |
27 return media_router::mojom::Issue::ActionType::DISMISS; | |
28 case media_router::IssueInfo::Action::LEARN_MORE: | |
29 return media_router::mojom::Issue::ActionType::LEARN_MORE; | |
30 } | |
31 NOTREACHED() << "Unknown issue action type " << static_cast<int>(action); | |
32 return media_router::mojom::Issue::ActionType::DISMISS; | |
33 } | |
34 | |
35 static bool FromMojom(media_router::mojom::Issue::ActionType input, | |
36 media_router::IssueInfo::Action* output) { | |
37 switch (input) { | |
38 case media_router::mojom::Issue::ActionType::DISMISS: | |
39 *output = media_router::IssueInfo::Action::DISMISS; | |
40 return true; | |
41 case media_router::mojom::Issue::ActionType::LEARN_MORE: | |
42 *output = media_router::IssueInfo::Action::LEARN_MORE; | |
43 return true; | |
44 } | |
45 return false; | |
46 } | |
47 }; | |
48 | |
49 template <> | |
50 struct EnumTraits<media_router::mojom::Issue::Severity, | |
51 media_router::IssueInfo::Severity> { | |
52 static media_router::mojom::Issue::Severity ToMojom( | |
53 media_router::IssueInfo::Severity severity) { | |
54 switch (severity) { | |
55 case media_router::IssueInfo::Severity::FATAL: | |
56 return media_router::mojom::Issue::Severity::FATAL; | |
57 case media_router::IssueInfo::Severity::WARNING: | |
58 return media_router::mojom::Issue::Severity::WARNING; | |
59 case media_router::IssueInfo::Severity::NOTIFICATION: | |
60 return media_router::mojom::Issue::Severity::NOTIFICATION; | |
61 } | |
62 NOTREACHED() << "Unknown issue severity " << static_cast<int>(severity); | |
63 return media_router::mojom::Issue::Severity::WARNING; | |
64 } | |
65 | |
66 static bool FromMojom(media_router::mojom::Issue::Severity input, | |
67 media_router::IssueInfo::Severity* output) { | |
68 switch (input) { | |
69 case media_router::mojom::Issue::Severity::FATAL: | |
70 *output = media_router::IssueInfo::Severity::FATAL; | |
71 return true; | |
72 case media_router::mojom::Issue::Severity::WARNING: | |
73 *output = media_router::IssueInfo::Severity::WARNING; | |
74 return true; | |
75 case media_router::mojom::Issue::Severity::NOTIFICATION: | |
76 *output = media_router::IssueInfo::Severity::NOTIFICATION; | |
77 return true; | |
78 } | |
79 return false; | |
80 } | |
81 }; | |
82 | |
83 template <> | |
84 struct UnionTraits<media_router::mojom::MediaSinkExtraDataDataView, | |
85 media_router::MediaSinkInternal> { | |
86 static media_router::mojom::MediaSinkExtraDataDataView::Tag GetTag( | |
87 const media_router::MediaSinkInternal& sink); | |
88 | |
89 static bool IsNull(const media_router::MediaSinkInternal& sink) { | |
90 return !sink.is_cast_sink() && !sink.is_dial_sink(); | |
91 } | |
92 | |
93 static void SetToNull(media_router::MediaSinkInternal* out) {} | |
94 | |
95 static const media_router::DialSinkExtraData& dial_media_sink( | |
96 const media_router::MediaSinkInternal& sink) { | |
97 return sink.dial_data(); | |
98 } | |
99 | |
100 static const media_router::CastSinkExtraData& cast_media_sink( | |
101 const media_router::MediaSinkInternal& sink) { | |
102 return sink.cast_data(); | |
103 } | |
104 | |
105 static bool Read(media_router::mojom::MediaSinkExtraDataDataView data, | |
106 media_router::MediaSinkInternal* out); | |
107 }; | |
108 | |
109 template <> | |
110 struct StructTraits<media_router::mojom::DialMediaSinkDataView, | |
111 media_router::DialSinkExtraData> { | |
112 static const std::string& model_name( | |
113 const media_router::DialSinkExtraData& extra_data) { | |
114 return extra_data.model_name; | |
115 } | |
116 | |
117 static const net::IPAddress& ip_address( | |
118 const media_router::DialSinkExtraData& extra_data) { | |
119 return extra_data.ip_address; | |
120 } | |
121 | |
122 static const GURL& app_url( | |
123 const media_router::DialSinkExtraData& extra_data) { | |
124 return extra_data.app_url; | |
125 } | |
126 | |
127 static bool Read(media_router::mojom::DialMediaSinkDataView data, | |
128 media_router::DialSinkExtraData* out); | |
129 }; | |
130 | |
131 template <> | |
132 struct StructTraits<media_router::mojom::CastMediaSinkDataView, | |
133 media_router::CastSinkExtraData> { | |
134 static const std::string& model_name( | |
135 const media_router::CastSinkExtraData& extra_data) { | |
136 return extra_data.model_name; | |
137 } | |
138 | |
139 static const net::IPAddress& ip_address( | |
140 const media_router::CastSinkExtraData& extra_data) { | |
141 return extra_data.ip_address; | |
142 } | |
143 | |
144 static uint8_t capabilities( | |
145 const media_router::CastSinkExtraData& extra_data) { | |
146 return extra_data.capabilities; | |
147 } | |
148 | |
149 static int32_t cast_channel_id( | |
150 const media_router::CastSinkExtraData& extra_data) { | |
151 return extra_data.cast_channel_id; | |
152 } | |
153 | |
154 static bool Read(media_router::mojom::CastMediaSinkDataView data, | |
155 media_router::CastSinkExtraData* out); | |
156 }; | |
157 | |
158 template <> | |
159 struct StructTraits<media_router::mojom::RouteMessageDataView, | |
160 media_router::RouteMessage> { | |
161 static media_router::mojom::RouteMessage::Type type( | |
162 const media_router::RouteMessage& msg) { | |
163 switch (msg.type) { | |
164 case media_router::RouteMessage::TEXT: | |
165 return media_router::mojom::RouteMessage::Type::TEXT; | |
166 case media_router::RouteMessage::BINARY: | |
167 return media_router::mojom::RouteMessage::Type::BINARY; | |
168 } | |
169 NOTREACHED(); | |
170 return media_router::mojom::RouteMessage::Type::TEXT; | |
171 } | |
172 | |
173 static const base::Optional<std::string>& message( | |
174 const media_router::RouteMessage& msg) { | |
175 return msg.text; | |
176 } | |
177 | |
178 static const base::Optional<std::vector<uint8_t>>& data( | |
179 const media_router::RouteMessage& msg) { | |
180 return msg.binary; | |
181 } | |
182 | |
183 static bool Read(media_router::mojom::RouteMessageDataView data, | |
184 media_router::RouteMessage* out) { | |
185 media_router::mojom::RouteMessage::Type type; | |
186 if (!data.ReadType(&type)) | |
187 return false; | |
188 switch (type) { | |
189 case media_router::mojom::RouteMessage::Type::TEXT: { | |
190 out->type = media_router::RouteMessage::TEXT; | |
191 base::Optional<std::string> text; | |
192 if (!data.ReadMessage(&text) || !text) | |
193 return false; | |
194 out->text = std::move(text); | |
195 break; | |
196 } | |
197 case media_router::mojom::RouteMessage::Type::BINARY: { | |
198 out->type = media_router::RouteMessage::BINARY; | |
199 base::Optional<std::vector<uint8_t>> binary; | |
200 if (!data.ReadData(&binary) || !binary) | |
201 return false; | |
202 out->binary = std::move(binary); | |
203 break; | |
204 } | |
205 default: | |
206 return false; | |
207 } | |
208 return true; | |
209 } | |
210 }; | |
211 | |
212 template <> | |
213 struct StructTraits<media_router::mojom::IssueDataView, | |
214 media_router::IssueInfo> { | |
215 static bool Read(media_router::mojom::IssueDataView data, | |
216 media_router::IssueInfo* out); | |
217 | |
218 static base::Optional<std::string> route_id( | |
219 const media_router::IssueInfo& issue) { | |
220 return issue.route_id.empty() ? base::Optional<std::string>() | |
221 : base::make_optional(issue.route_id); | |
222 } | |
223 | |
224 static media_router::IssueInfo::Severity severity( | |
225 const media_router::IssueInfo& issue) { | |
226 return issue.severity; | |
227 } | |
228 | |
229 static bool is_blocking(const media_router::IssueInfo& issue) { | |
230 return issue.is_blocking; | |
231 } | |
232 | |
233 static std::string title(const media_router::IssueInfo& issue) { | |
234 return issue.title; | |
235 } | |
236 | |
237 static base::Optional<std::string> message( | |
238 const media_router::IssueInfo& issue) { | |
239 return issue.message.empty() ? base::Optional<std::string>() | |
240 : base::make_optional(issue.message); | |
241 } | |
242 | |
243 static media_router::IssueInfo::Action default_action( | |
244 const media_router::IssueInfo& issue) { | |
245 return issue.default_action; | |
246 } | |
247 | |
248 static base::Optional<std::vector<media_router::IssueInfo::Action>> | |
249 secondary_actions(const media_router::IssueInfo& issue) { | |
250 return issue.secondary_actions; | |
251 } | |
252 | |
253 static int32_t help_page_id(const media_router::IssueInfo& issue) { | |
254 return issue.help_page_id; | |
255 } | |
256 }; | |
257 | |
258 // MediaSink | |
259 | |
260 template <> | |
261 struct EnumTraits<media_router::mojom::MediaSink::IconType, | |
262 media_router::MediaSink::IconType> { | |
263 static media_router::mojom::MediaSink::IconType ToMojom( | |
264 media_router::MediaSink::IconType icon_type) { | |
265 switch (icon_type) { | |
266 case media_router::MediaSink::CAST: | |
267 return media_router::mojom::MediaSink::IconType::CAST; | |
268 case media_router::MediaSink::CAST_AUDIO: | |
269 return media_router::mojom::MediaSink::IconType::CAST_AUDIO; | |
270 case media_router::MediaSink::CAST_AUDIO_GROUP: | |
271 return media_router::mojom::MediaSink::IconType::CAST_AUDIO_GROUP; | |
272 case media_router::MediaSink::HANGOUT: | |
273 return media_router::mojom::MediaSink::IconType::HANGOUT; | |
274 case media_router::MediaSink::MEETING: | |
275 return media_router::mojom::MediaSink::IconType::MEETING; | |
276 case media_router::MediaSink::GENERIC: | |
277 return media_router::mojom::MediaSink::IconType::GENERIC; | |
278 } | |
279 NOTREACHED() << "Unknown sink icon type " << static_cast<int>(icon_type); | |
280 return media_router::mojom::MediaSink::IconType::GENERIC; | |
281 } | |
282 | |
283 static bool FromMojom(media_router::mojom::MediaSink::IconType input, | |
284 media_router::MediaSink::IconType* output) { | |
285 switch (input) { | |
286 case media_router::mojom::MediaSink::IconType::CAST: | |
287 *output = media_router::MediaSink::CAST; | |
288 return true; | |
289 case media_router::mojom::MediaSink::IconType::CAST_AUDIO: | |
290 *output = media_router::MediaSink::CAST_AUDIO; | |
291 return true; | |
292 case media_router::mojom::MediaSink::IconType::CAST_AUDIO_GROUP: | |
293 *output = media_router::MediaSink::CAST_AUDIO_GROUP; | |
294 return true; | |
295 case media_router::mojom::MediaSink::IconType::HANGOUT: | |
296 *output = media_router::MediaSink::HANGOUT; | |
297 return true; | |
298 case media_router::mojom::MediaSink::IconType::MEETING: | |
299 *output = media_router::MediaSink::MEETING; | |
300 return true; | |
301 case media_router::mojom::MediaSink::IconType::GENERIC: | |
302 *output = media_router::MediaSink::GENERIC; | |
303 return true; | |
304 } | |
305 return false; | |
306 } | |
307 }; | |
308 | |
309 template <> | |
310 struct StructTraits<media_router::mojom::MediaSinkDataView, | |
311 media_router::MediaSinkInternal> { | |
312 static bool Read(media_router::mojom::MediaSinkDataView data, | |
313 media_router::MediaSinkInternal* out); | |
314 | |
315 static std::string sink_id( | |
316 const media_router::MediaSinkInternal& sink_internal) { | |
317 return sink_internal.sink().id(); | |
318 } | |
319 | |
320 static std::string name( | |
321 const media_router::MediaSinkInternal& sink_internal) { | |
322 return sink_internal.sink().name(); | |
323 } | |
324 | |
325 static base::Optional<std::string> description( | |
326 const media_router::MediaSinkInternal& sink_internal) { | |
327 return sink_internal.sink().description(); | |
328 } | |
329 | |
330 static base::Optional<std::string> domain( | |
331 const media_router::MediaSinkInternal& sink_internal) { | |
332 return sink_internal.sink().domain(); | |
333 } | |
334 | |
335 static media_router::MediaSink::IconType icon_type( | |
336 const media_router::MediaSinkInternal& sink_internal) { | |
337 return sink_internal.sink().icon_type(); | |
338 } | |
339 | |
340 static const media_router::MediaSinkInternal& extra_data( | |
341 const media_router::MediaSinkInternal& sink_internal) { | |
342 return sink_internal; | |
343 } | |
344 }; | |
345 | |
346 // MediaRoute | |
347 | |
348 template <> | |
349 struct StructTraits<media_router::mojom::MediaRouteDataView, | |
350 media_router::MediaRoute> { | |
351 static bool Read(media_router::mojom::MediaRouteDataView data, | |
352 media_router::MediaRoute* out); | |
353 | |
354 static std::string media_route_id(const media_router::MediaRoute& route) { | |
355 return route.media_route_id(); | |
356 } | |
357 | |
358 static base::Optional<std::string> media_source( | |
359 const media_router::MediaRoute& route) { | |
360 // TODO(imcheng): If we ever convert from Mojo to C++ outside of unit tests, | |
361 // it would be better to make the |media_source_| field on MediaRoute a | |
362 // base::Optional<MediaSource::Id> instead so it can be returned directly | |
363 // here. | |
364 return route.media_source().id().empty() | |
365 ? base::Optional<std::string>() | |
366 : base::make_optional(route.media_source().id()); | |
367 } | |
368 | |
369 static std::string media_sink_id(const media_router::MediaRoute& route) { | |
370 return route.media_sink_id(); | |
371 } | |
372 | |
373 static std::string description(const media_router::MediaRoute& route) { | |
374 return route.description(); | |
375 } | |
376 | |
377 static bool is_local(const media_router::MediaRoute& route) { | |
378 return route.is_local(); | |
379 } | |
380 | |
381 static base::Optional<std::string> custom_controller_path( | |
382 const media_router::MediaRoute& route) { | |
383 return route.custom_controller_path().empty() | |
384 ? base::Optional<std::string>() | |
385 : base::make_optional(route.custom_controller_path()); | |
386 } | |
387 | |
388 static bool for_display(const media_router::MediaRoute& route) { | |
389 return route.for_display(); | |
390 } | |
391 | |
392 static bool is_incognito(const media_router::MediaRoute& route) { | |
393 return route.is_incognito(); | |
394 } | |
395 | |
396 static bool is_offscreen_presentation(const media_router::MediaRoute& route) { | |
397 return route.is_offscreen_presentation(); | |
398 } | |
399 }; | |
400 | |
401 // PresentationConnectionState | |
402 | |
403 template <> | |
404 struct EnumTraits<media_router::mojom::MediaRouter::PresentationConnectionState, | |
405 content::PresentationConnectionState> { | |
406 static media_router::mojom::MediaRouter::PresentationConnectionState ToMojom( | |
407 content::PresentationConnectionState state) { | |
408 switch (state) { | |
409 case content::PRESENTATION_CONNECTION_STATE_CONNECTING: | |
410 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
411 CONNECTING; | |
412 case content::PRESENTATION_CONNECTION_STATE_CONNECTED: | |
413 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
414 CONNECTED; | |
415 case content::PRESENTATION_CONNECTION_STATE_CLOSED: | |
416 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
417 CLOSED; | |
418 case content::PRESENTATION_CONNECTION_STATE_TERMINATED: | |
419 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
420 TERMINATED; | |
421 } | |
422 NOTREACHED() << "Unknown PresentationConnectionState " | |
423 << static_cast<int>(state); | |
424 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
425 TERMINATED; | |
426 } | |
427 | |
428 static bool FromMojom( | |
429 media_router::mojom::MediaRouter::PresentationConnectionState input, | |
430 content::PresentationConnectionState* state) { | |
431 switch (input) { | |
432 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
433 CONNECTING: | |
434 *state = content::PRESENTATION_CONNECTION_STATE_CONNECTING; | |
435 return true; | |
436 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
437 CONNECTED: | |
438 *state = content::PRESENTATION_CONNECTION_STATE_CONNECTED; | |
439 return true; | |
440 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
441 CLOSED: | |
442 *state = content::PRESENTATION_CONNECTION_STATE_CLOSED; | |
443 return true; | |
444 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
445 TERMINATED: | |
446 *state = content::PRESENTATION_CONNECTION_STATE_TERMINATED; | |
447 return true; | |
448 } | |
449 return false; | |
450 } | |
451 }; | |
452 | |
453 // PresentationConnectionCloseReason | |
454 | |
455 template <> | |
456 struct EnumTraits< | |
457 media_router::mojom::MediaRouter::PresentationConnectionCloseReason, | |
458 content::PresentationConnectionCloseReason> { | |
459 static media_router::mojom::MediaRouter::PresentationConnectionCloseReason | |
460 ToMojom(content::PresentationConnectionCloseReason reason) { | |
461 switch (reason) { | |
462 case content::PRESENTATION_CONNECTION_CLOSE_REASON_CONNECTION_ERROR: | |
463 return media_router::mojom::MediaRouter:: | |
464 PresentationConnectionCloseReason::CONNECTION_ERROR; | |
465 case content::PRESENTATION_CONNECTION_CLOSE_REASON_CLOSED: | |
466 return media_router::mojom::MediaRouter:: | |
467 PresentationConnectionCloseReason::CLOSED; | |
468 case content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY: | |
469 return media_router::mojom::MediaRouter:: | |
470 PresentationConnectionCloseReason::WENT_AWAY; | |
471 } | |
472 NOTREACHED() << "Unknown PresentationConnectionCloseReason " | |
473 << static_cast<int>(reason); | |
474 return media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
475 CONNECTION_ERROR; | |
476 } | |
477 | |
478 static bool FromMojom( | |
479 media_router::mojom::MediaRouter::PresentationConnectionCloseReason input, | |
480 content::PresentationConnectionCloseReason* state) { | |
481 switch (input) { | |
482 case media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
483 CONNECTION_ERROR: | |
484 *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_CONNECTION_ERROR; | |
485 return true; | |
486 case media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
487 CLOSED: | |
488 *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_CLOSED; | |
489 return true; | |
490 case media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
491 WENT_AWAY: | |
492 *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY; | |
493 return true; | |
494 } | |
495 return false; | |
496 } | |
497 }; | |
498 | |
499 // RouteRequestResultCode | |
500 | |
501 template <> | |
502 struct EnumTraits<media_router::mojom::RouteRequestResultCode, | |
503 media_router::RouteRequestResult::ResultCode> { | |
504 static media_router::mojom::RouteRequestResultCode ToMojom( | |
505 media_router::RouteRequestResult::ResultCode code) { | |
506 switch (code) { | |
507 case media_router::RouteRequestResult::UNKNOWN_ERROR: | |
508 return media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR; | |
509 case media_router::RouteRequestResult::OK: | |
510 return media_router::mojom::RouteRequestResultCode::OK; | |
511 case media_router::RouteRequestResult::TIMED_OUT: | |
512 return media_router::mojom::RouteRequestResultCode::TIMED_OUT; | |
513 case media_router::RouteRequestResult::ROUTE_NOT_FOUND: | |
514 return media_router::mojom::RouteRequestResultCode::ROUTE_NOT_FOUND; | |
515 case media_router::RouteRequestResult::SINK_NOT_FOUND: | |
516 return media_router::mojom::RouteRequestResultCode::SINK_NOT_FOUND; | |
517 case media_router::RouteRequestResult::INVALID_ORIGIN: | |
518 return media_router::mojom::RouteRequestResultCode::INVALID_ORIGIN; | |
519 case media_router::RouteRequestResult::INCOGNITO_MISMATCH: | |
520 return media_router::mojom::RouteRequestResultCode::INCOGNITO_MISMATCH; | |
521 case media_router::RouteRequestResult::NO_SUPPORTED_PROVIDER: | |
522 return media_router::mojom::RouteRequestResultCode:: | |
523 NO_SUPPORTED_PROVIDER; | |
524 case media_router::RouteRequestResult::CANCELLED: | |
525 return media_router::mojom::RouteRequestResultCode::CANCELLED; | |
526 default: | |
527 NOTREACHED() << "Unknown RouteRequestResultCode " | |
528 << static_cast<int>(code); | |
529 return media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR; | |
530 } | |
531 } | |
532 | |
533 static bool FromMojom(media_router::mojom::RouteRequestResultCode input, | |
534 media_router::RouteRequestResult::ResultCode* output) { | |
535 switch (input) { | |
536 case media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR: | |
537 *output = media_router::RouteRequestResult::UNKNOWN_ERROR; | |
538 return true; | |
539 case media_router::mojom::RouteRequestResultCode::OK: | |
540 *output = media_router::RouteRequestResult::OK; | |
541 return true; | |
542 case media_router::mojom::RouteRequestResultCode::TIMED_OUT: | |
543 *output = media_router::RouteRequestResult::TIMED_OUT; | |
544 return true; | |
545 case media_router::mojom::RouteRequestResultCode::ROUTE_NOT_FOUND: | |
546 *output = media_router::RouteRequestResult::ROUTE_NOT_FOUND; | |
547 return true; | |
548 case media_router::mojom::RouteRequestResultCode::SINK_NOT_FOUND: | |
549 *output = media_router::RouteRequestResult::SINK_NOT_FOUND; | |
550 return true; | |
551 case media_router::mojom::RouteRequestResultCode::INVALID_ORIGIN: | |
552 *output = media_router::RouteRequestResult::INVALID_ORIGIN; | |
553 return true; | |
554 case media_router::mojom::RouteRequestResultCode::INCOGNITO_MISMATCH: | |
555 *output = media_router::RouteRequestResult::INCOGNITO_MISMATCH; | |
556 return true; | |
557 case media_router::mojom::RouteRequestResultCode::NO_SUPPORTED_PROVIDER: | |
558 *output = media_router::RouteRequestResult::NO_SUPPORTED_PROVIDER; | |
559 return true; | |
560 case media_router::mojom::RouteRequestResultCode::CANCELLED: | |
561 *output = media_router::RouteRequestResult::CANCELLED; | |
562 return true; | |
563 } | |
564 return false; | |
565 } | |
566 }; | |
567 | |
568 } // namespace mojo | |
569 | |
570 #endif // CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_STRUCT_TRAITS_H_ | |
OLD | NEW |