| 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::GENERIC: | |
| 275 return media_router::mojom::MediaSink::IconType::GENERIC; | |
| 276 } | |
| 277 NOTREACHED() << "Unknown sink icon type " << static_cast<int>(icon_type); | |
| 278 return media_router::mojom::MediaSink::IconType::GENERIC; | |
| 279 } | |
| 280 | |
| 281 static bool FromMojom(media_router::mojom::MediaSink::IconType input, | |
| 282 media_router::MediaSink::IconType* output) { | |
| 283 switch (input) { | |
| 284 case media_router::mojom::MediaSink::IconType::CAST: | |
| 285 *output = media_router::MediaSink::CAST; | |
| 286 return true; | |
| 287 case media_router::mojom::MediaSink::IconType::CAST_AUDIO: | |
| 288 *output = media_router::MediaSink::CAST_AUDIO; | |
| 289 return true; | |
| 290 case media_router::mojom::MediaSink::IconType::CAST_AUDIO_GROUP: | |
| 291 *output = media_router::MediaSink::CAST_AUDIO_GROUP; | |
| 292 return true; | |
| 293 case media_router::mojom::MediaSink::IconType::HANGOUT: | |
| 294 *output = media_router::MediaSink::HANGOUT; | |
| 295 return true; | |
| 296 case media_router::mojom::MediaSink::IconType::GENERIC: | |
| 297 *output = media_router::MediaSink::GENERIC; | |
| 298 return true; | |
| 299 } | |
| 300 return false; | |
| 301 } | |
| 302 }; | |
| 303 | |
| 304 template <> | |
| 305 struct StructTraits<media_router::mojom::MediaSinkDataView, | |
| 306 media_router::MediaSinkInternal> { | |
| 307 static bool Read(media_router::mojom::MediaSinkDataView data, | |
| 308 media_router::MediaSinkInternal* out); | |
| 309 | |
| 310 static std::string sink_id( | |
| 311 const media_router::MediaSinkInternal& sink_internal) { | |
| 312 return sink_internal.sink().id(); | |
| 313 } | |
| 314 | |
| 315 static std::string name( | |
| 316 const media_router::MediaSinkInternal& sink_internal) { | |
| 317 return sink_internal.sink().name(); | |
| 318 } | |
| 319 | |
| 320 static base::Optional<std::string> description( | |
| 321 const media_router::MediaSinkInternal& sink_internal) { | |
| 322 return sink_internal.sink().description(); | |
| 323 } | |
| 324 | |
| 325 static base::Optional<std::string> domain( | |
| 326 const media_router::MediaSinkInternal& sink_internal) { | |
| 327 return sink_internal.sink().domain(); | |
| 328 } | |
| 329 | |
| 330 static media_router::MediaSink::IconType icon_type( | |
| 331 const media_router::MediaSinkInternal& sink_internal) { | |
| 332 return sink_internal.sink().icon_type(); | |
| 333 } | |
| 334 | |
| 335 static const media_router::MediaSinkInternal& extra_data( | |
| 336 const media_router::MediaSinkInternal& sink_internal) { | |
| 337 return sink_internal; | |
| 338 } | |
| 339 }; | |
| 340 | |
| 341 // MediaRoute | |
| 342 | |
| 343 template <> | |
| 344 struct StructTraits<media_router::mojom::MediaRouteDataView, | |
| 345 media_router::MediaRoute> { | |
| 346 static bool Read(media_router::mojom::MediaRouteDataView data, | |
| 347 media_router::MediaRoute* out); | |
| 348 | |
| 349 static std::string media_route_id(const media_router::MediaRoute& route) { | |
| 350 return route.media_route_id(); | |
| 351 } | |
| 352 | |
| 353 static base::Optional<std::string> media_source( | |
| 354 const media_router::MediaRoute& route) { | |
| 355 // TODO(imcheng): If we ever convert from Mojo to C++ outside of unit tests, | |
| 356 // it would be better to make the |media_source_| field on MediaRoute a | |
| 357 // base::Optional<MediaSource::Id> instead so it can be returned directly | |
| 358 // here. | |
| 359 return route.media_source().id().empty() | |
| 360 ? base::Optional<std::string>() | |
| 361 : base::make_optional(route.media_source().id()); | |
| 362 } | |
| 363 | |
| 364 static std::string media_sink_id(const media_router::MediaRoute& route) { | |
| 365 return route.media_sink_id(); | |
| 366 } | |
| 367 | |
| 368 static std::string description(const media_router::MediaRoute& route) { | |
| 369 return route.description(); | |
| 370 } | |
| 371 | |
| 372 static bool is_local(const media_router::MediaRoute& route) { | |
| 373 return route.is_local(); | |
| 374 } | |
| 375 | |
| 376 static base::Optional<std::string> custom_controller_path( | |
| 377 const media_router::MediaRoute& route) { | |
| 378 return route.custom_controller_path().empty() | |
| 379 ? base::Optional<std::string>() | |
| 380 : base::make_optional(route.custom_controller_path()); | |
| 381 } | |
| 382 | |
| 383 static bool for_display(const media_router::MediaRoute& route) { | |
| 384 return route.for_display(); | |
| 385 } | |
| 386 | |
| 387 static bool is_incognito(const media_router::MediaRoute& route) { | |
| 388 return route.is_incognito(); | |
| 389 } | |
| 390 | |
| 391 static bool is_offscreen_presentation(const media_router::MediaRoute& route) { | |
| 392 return route.is_offscreen_presentation(); | |
| 393 } | |
| 394 }; | |
| 395 | |
| 396 // PresentationConnectionState | |
| 397 | |
| 398 template <> | |
| 399 struct EnumTraits<media_router::mojom::MediaRouter::PresentationConnectionState, | |
| 400 content::PresentationConnectionState> { | |
| 401 static media_router::mojom::MediaRouter::PresentationConnectionState ToMojom( | |
| 402 content::PresentationConnectionState state) { | |
| 403 switch (state) { | |
| 404 case content::PRESENTATION_CONNECTION_STATE_CONNECTING: | |
| 405 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 406 CONNECTING; | |
| 407 case content::PRESENTATION_CONNECTION_STATE_CONNECTED: | |
| 408 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 409 CONNECTED; | |
| 410 case content::PRESENTATION_CONNECTION_STATE_CLOSED: | |
| 411 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 412 CLOSED; | |
| 413 case content::PRESENTATION_CONNECTION_STATE_TERMINATED: | |
| 414 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 415 TERMINATED; | |
| 416 } | |
| 417 NOTREACHED() << "Unknown PresentationConnectionState " | |
| 418 << static_cast<int>(state); | |
| 419 return media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 420 TERMINATED; | |
| 421 } | |
| 422 | |
| 423 static bool FromMojom( | |
| 424 media_router::mojom::MediaRouter::PresentationConnectionState input, | |
| 425 content::PresentationConnectionState* state) { | |
| 426 switch (input) { | |
| 427 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 428 CONNECTING: | |
| 429 *state = content::PRESENTATION_CONNECTION_STATE_CONNECTING; | |
| 430 return true; | |
| 431 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 432 CONNECTED: | |
| 433 *state = content::PRESENTATION_CONNECTION_STATE_CONNECTED; | |
| 434 return true; | |
| 435 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 436 CLOSED: | |
| 437 *state = content::PRESENTATION_CONNECTION_STATE_CLOSED; | |
| 438 return true; | |
| 439 case media_router::mojom::MediaRouter::PresentationConnectionState:: | |
| 440 TERMINATED: | |
| 441 *state = content::PRESENTATION_CONNECTION_STATE_TERMINATED; | |
| 442 return true; | |
| 443 } | |
| 444 return false; | |
| 445 } | |
| 446 }; | |
| 447 | |
| 448 // PresentationConnectionCloseReason | |
| 449 | |
| 450 template <> | |
| 451 struct EnumTraits< | |
| 452 media_router::mojom::MediaRouter::PresentationConnectionCloseReason, | |
| 453 content::PresentationConnectionCloseReason> { | |
| 454 static media_router::mojom::MediaRouter::PresentationConnectionCloseReason | |
| 455 ToMojom(content::PresentationConnectionCloseReason reason) { | |
| 456 switch (reason) { | |
| 457 case content::PRESENTATION_CONNECTION_CLOSE_REASON_CONNECTION_ERROR: | |
| 458 return media_router::mojom::MediaRouter:: | |
| 459 PresentationConnectionCloseReason::CONNECTION_ERROR; | |
| 460 case content::PRESENTATION_CONNECTION_CLOSE_REASON_CLOSED: | |
| 461 return media_router::mojom::MediaRouter:: | |
| 462 PresentationConnectionCloseReason::CLOSED; | |
| 463 case content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY: | |
| 464 return media_router::mojom::MediaRouter:: | |
| 465 PresentationConnectionCloseReason::WENT_AWAY; | |
| 466 } | |
| 467 NOTREACHED() << "Unknown PresentationConnectionCloseReason " | |
| 468 << static_cast<int>(reason); | |
| 469 return media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
| 470 CONNECTION_ERROR; | |
| 471 } | |
| 472 | |
| 473 static bool FromMojom( | |
| 474 media_router::mojom::MediaRouter::PresentationConnectionCloseReason input, | |
| 475 content::PresentationConnectionCloseReason* state) { | |
| 476 switch (input) { | |
| 477 case media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
| 478 CONNECTION_ERROR: | |
| 479 *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_CONNECTION_ERROR; | |
| 480 return true; | |
| 481 case media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
| 482 CLOSED: | |
| 483 *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_CLOSED; | |
| 484 return true; | |
| 485 case media_router::mojom::MediaRouter::PresentationConnectionCloseReason:: | |
| 486 WENT_AWAY: | |
| 487 *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY; | |
| 488 return true; | |
| 489 } | |
| 490 return false; | |
| 491 } | |
| 492 }; | |
| 493 | |
| 494 // RouteRequestResultCode | |
| 495 | |
| 496 template <> | |
| 497 struct EnumTraits<media_router::mojom::RouteRequestResultCode, | |
| 498 media_router::RouteRequestResult::ResultCode> { | |
| 499 static media_router::mojom::RouteRequestResultCode ToMojom( | |
| 500 media_router::RouteRequestResult::ResultCode code) { | |
| 501 switch (code) { | |
| 502 case media_router::RouteRequestResult::UNKNOWN_ERROR: | |
| 503 return media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR; | |
| 504 case media_router::RouteRequestResult::OK: | |
| 505 return media_router::mojom::RouteRequestResultCode::OK; | |
| 506 case media_router::RouteRequestResult::TIMED_OUT: | |
| 507 return media_router::mojom::RouteRequestResultCode::TIMED_OUT; | |
| 508 case media_router::RouteRequestResult::ROUTE_NOT_FOUND: | |
| 509 return media_router::mojom::RouteRequestResultCode::ROUTE_NOT_FOUND; | |
| 510 case media_router::RouteRequestResult::SINK_NOT_FOUND: | |
| 511 return media_router::mojom::RouteRequestResultCode::SINK_NOT_FOUND; | |
| 512 case media_router::RouteRequestResult::INVALID_ORIGIN: | |
| 513 return media_router::mojom::RouteRequestResultCode::INVALID_ORIGIN; | |
| 514 case media_router::RouteRequestResult::INCOGNITO_MISMATCH: | |
| 515 return media_router::mojom::RouteRequestResultCode::INCOGNITO_MISMATCH; | |
| 516 case media_router::RouteRequestResult::NO_SUPPORTED_PROVIDER: | |
| 517 return media_router::mojom::RouteRequestResultCode:: | |
| 518 NO_SUPPORTED_PROVIDER; | |
| 519 case media_router::RouteRequestResult::CANCELLED: | |
| 520 return media_router::mojom::RouteRequestResultCode::CANCELLED; | |
| 521 default: | |
| 522 NOTREACHED() << "Unknown RouteRequestResultCode " | |
| 523 << static_cast<int>(code); | |
| 524 return media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR; | |
| 525 } | |
| 526 } | |
| 527 | |
| 528 static bool FromMojom(media_router::mojom::RouteRequestResultCode input, | |
| 529 media_router::RouteRequestResult::ResultCode* output) { | |
| 530 switch (input) { | |
| 531 case media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR: | |
| 532 *output = media_router::RouteRequestResult::UNKNOWN_ERROR; | |
| 533 return true; | |
| 534 case media_router::mojom::RouteRequestResultCode::OK: | |
| 535 *output = media_router::RouteRequestResult::OK; | |
| 536 return true; | |
| 537 case media_router::mojom::RouteRequestResultCode::TIMED_OUT: | |
| 538 *output = media_router::RouteRequestResult::TIMED_OUT; | |
| 539 return true; | |
| 540 case media_router::mojom::RouteRequestResultCode::ROUTE_NOT_FOUND: | |
| 541 *output = media_router::RouteRequestResult::ROUTE_NOT_FOUND; | |
| 542 return true; | |
| 543 case media_router::mojom::RouteRequestResultCode::SINK_NOT_FOUND: | |
| 544 *output = media_router::RouteRequestResult::SINK_NOT_FOUND; | |
| 545 return true; | |
| 546 case media_router::mojom::RouteRequestResultCode::INVALID_ORIGIN: | |
| 547 *output = media_router::RouteRequestResult::INVALID_ORIGIN; | |
| 548 return true; | |
| 549 case media_router::mojom::RouteRequestResultCode::INCOGNITO_MISMATCH: | |
| 550 *output = media_router::RouteRequestResult::INCOGNITO_MISMATCH; | |
| 551 return true; | |
| 552 case media_router::mojom::RouteRequestResultCode::NO_SUPPORTED_PROVIDER: | |
| 553 *output = media_router::RouteRequestResult::NO_SUPPORTED_PROVIDER; | |
| 554 return true; | |
| 555 case media_router::mojom::RouteRequestResultCode::CANCELLED: | |
| 556 *output = media_router::RouteRequestResult::CANCELLED; | |
| 557 return true; | |
| 558 } | |
| 559 return false; | |
| 560 } | |
| 561 }; | |
| 562 | |
| 563 } // namespace mojo | |
| 564 | |
| 565 #endif // CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_STRUCT_TRAITS_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2771413003:
Move c/b/media/router/mojo/*.mojom to chrome/common/media_router/mojo/*.mojom (Closed)
