[Media Router] Convert to use typemaps for media_router.mojom.

chrome/browser/media/router/mojo/media_router_struct_traits.h

Index: chrome/browser/media/router/mojo/media_router_struct_traits.h
diff --git a/chrome/browser/media/router/mojo/media_router_struct_traits.h b/chrome/browser/media/router/mojo/media_router_struct_traits.h
index 67edb860e620cf623e24bf77e86b515d18b30119..24544209552f1c157e345beef35a33760beadd55 100644
--- a/chrome/browser/media/router/mojo/media_router_struct_traits.h
+++ b/chrome/browser/media/router/mojo/media_router_struct_traits.h
@@ -8,11 +8,15 @@
 #include <string>
 
 #include "chrome/browser/media/router/issue.h"
+#include "chrome/browser/media/router/media_sink.h"
 #include "chrome/browser/media/router/mojo/media_router.mojom.h"
+#include "chrome/browser/media/router/route_request_result.h"
 #include "mojo/common/common_custom_types_struct_traits.h"
 
 namespace mojo {
 
+// Issue
+
 template <>
 struct EnumTraits<media_router::mojom::Issue::ActionType,
                   media_router::IssueInfo::Action> {
@@ -176,6 +180,302 @@ struct StructTraits<media_router::mojom::IssueDataView,
   }
 };
 
+// MediaSink
+
+template <>
+struct EnumTraits<media_router::mojom::MediaSink::IconType,
+                  media_router::MediaSink::IconType> {
+  static media_router::mojom::MediaSink::IconType ToMojom(
+      media_router::MediaSink::IconType icon_type) {
+    switch (icon_type) {
+      case media_router::MediaSink::CAST:
+        return media_router::mojom::MediaSink::IconType::CAST;
+      case media_router::MediaSink::CAST_AUDIO:
+        return media_router::mojom::MediaSink::IconType::CAST_AUDIO;
+      case media_router::MediaSink::CAST_AUDIO_GROUP:
+        return media_router::mojom::MediaSink::IconType::CAST_AUDIO_GROUP;
+      case media_router::MediaSink::HANGOUT:
+        return media_router::mojom::MediaSink::IconType::HANGOUT;
+      case media_router::MediaSink::GENERIC:
+        return media_router::mojom::MediaSink::IconType::GENERIC;
+    }
+    NOTREACHED() << "Unknown sink icon type " << static_cast<int>(icon_type);
+    return media_router::mojom::MediaSink::IconType::GENERIC;
+  }
+
+  static bool FromMojom(media_router::mojom::MediaSink::IconType input,
+                        media_router::MediaSink::IconType* output) {
+    switch (input) {
+      case media_router::mojom::MediaSink::IconType::CAST:
+        *output = media_router::MediaSink::CAST;
+        return true;
+      case media_router::mojom::MediaSink::IconType::CAST_AUDIO:
+        *output = media_router::MediaSink::CAST_AUDIO;
+        return true;
+      case media_router::mojom::MediaSink::IconType::CAST_AUDIO_GROUP:
+        *output = media_router::MediaSink::CAST_AUDIO_GROUP;
+        return true;
+      case media_router::mojom::MediaSink::IconType::HANGOUT:
+        *output = media_router::MediaSink::HANGOUT;
+        return true;
+      case media_router::mojom::MediaSink::IconType::GENERIC:
+        *output = media_router::MediaSink::GENERIC;
+        return true;
+    }
+    return false;
+  }
+};
+
+template <>
+struct StructTraits<media_router::mojom::MediaSinkDataView,
+                    media_router::MediaSink> {
+  static bool Read(media_router::mojom::MediaSinkDataView data,
+                   media_router::MediaSink* out);
+
+  static std::string sink_id(const media_router::MediaSink& sink) {
+    return sink.id();
+  }
+
+  static std::string name(const media_router::MediaSink& sink) {
+    return sink.name();
+  }
+
+  static base::Optional<std::string> description(
+      const media_router::MediaSink& sink) {
+    return sink.description().empty() ? base::Optional<std::string>()
+                                      : base::make_optional(sink.description());

[dcheng, 2017/02/01 22:51:08]

It's not ideal to do this, since Mojo invokes getters twice during
serialization. Is it possible/does it make sense to just make it Optional on
media_router::MediaSink.

[imcheng, 2017/02/02 21:20:37]

Done for description and domain. I haven't done it for MediaRoute because we
don't actually serialize them from C++ to Mojo. (We will for MediaSink for an
upcoming project)

[dcheng, 2017/02/05 05:42:55]

OK, please add a NOTREACHED() or something in there to indicate that for now?
Then we can fix it when it's used.

[imcheng, 2017/02/06 23:39:34]

Done.

+  }
+
+  static base::Optional<std::string> domain(
+      const media_router::MediaSink& sink) {
+    return sink.domain().empty() ? base::Optional<std::string>()
+                                 : base::make_optional(sink.domain());
+  }
+
+  static media_router::MediaSink::IconType icon_type(
+      const media_router::MediaSink& sink) {
+    return sink.icon_type();
+  }
+};
+
+// MediaRoute
+
+template <>
+struct StructTraits<media_router::mojom::MediaRouteDataView,
+                    media_router::MediaRoute> {
+  static bool Read(media_router::mojom::MediaRouteDataView data,
+                   media_router::MediaRoute* out);
+
+  static std::string media_route_id(const media_router::MediaRoute& route) {
+    return route.media_route_id();
+  }
+
+  static base::Optional<std::string> media_source(
+      const media_router::MediaRoute& route) {
+    return route.media_source().id().empty()
+               ? base::Optional<std::string>()
+               : base::make_optional(route.media_source().id());
+  }
+
+  static std::string media_sink_id(const media_router::MediaRoute& route) {
+    return route.media_sink_id();
+  }
+
+  static std::string description(const media_router::MediaRoute& route) {
+    return route.description();
+  }
+
+  static bool is_local(const media_router::MediaRoute& route) {
+    return route.is_local();
+  }
+
+  static base::Optional<std::string> custom_controller_path(
+      const media_router::MediaRoute& route) {
+    return route.custom_controller_path().empty()
+               ? base::Optional<std::string>()
+               : base::make_optional(route.custom_controller_path());
+  }
+
+  static bool for_display(const media_router::MediaRoute& route) {
+    return route.for_display();
+  }
+
+  static bool is_incognito(const media_router::MediaRoute& route) {
+    return route.is_incognito();
+  }
+
+  static bool is_offscreen_presentation(const media_router::MediaRoute& route) {
+    return route.is_offscreen_presentation();
+  }
+};
+
+// PresentationConnectionState
+
+template <>
+struct EnumTraits<media_router::mojom::MediaRouter::PresentationConnectionState,
+                  content::PresentationConnectionState> {
+  static media_router::mojom::MediaRouter::PresentationConnectionState ToMojom(
+      content::PresentationConnectionState state) {
+    switch (state) {
+      case content::PRESENTATION_CONNECTION_STATE_CONNECTING:
+        return media_router::mojom::MediaRouter::PresentationConnectionState::
+            CONNECTING;
+      case content::PRESENTATION_CONNECTION_STATE_CONNECTED:
+        return media_router::mojom::MediaRouter::PresentationConnectionState::
+            CONNECTED;
+      case content::PRESENTATION_CONNECTION_STATE_CLOSED:
+        return media_router::mojom::MediaRouter::PresentationConnectionState::
+            CLOSED;
+      case content::PRESENTATION_CONNECTION_STATE_TERMINATED:
+        return media_router::mojom::MediaRouter::PresentationConnectionState::
+            TERMINATED;
+    }
+    NOTREACHED() << "Unknown PresentationConnectionState "
+                 << static_cast<int>(state);
+    return media_router::mojom::MediaRouter::PresentationConnectionState::
+        TERMINATED;
+  }
+
+  static bool FromMojom(
+      media_router::mojom::MediaRouter::PresentationConnectionState input,
+      content::PresentationConnectionState* state) {
+    switch (input) {
+      case media_router::mojom::MediaRouter::PresentationConnectionState::
+          CONNECTING:
+        *state = content::PRESENTATION_CONNECTION_STATE_CONNECTING;
+        return true;
+      case media_router::mojom::MediaRouter::PresentationConnectionState::
+          CONNECTED:
+        *state = content::PRESENTATION_CONNECTION_STATE_CONNECTED;
+        return true;
+      case media_router::mojom::MediaRouter::PresentationConnectionState::
+          CLOSED:
+        *state = content::PRESENTATION_CONNECTION_STATE_CLOSED;
+        return true;
+      case media_router::mojom::MediaRouter::PresentationConnectionState::
+          TERMINATED:
+        *state = content::PRESENTATION_CONNECTION_STATE_TERMINATED;
+        return true;
+    }
+    return false;
+  }
+};
+
+// PresentationConnectionCloseReason
+
+template <>
+struct EnumTraits<
+    media_router::mojom::MediaRouter::PresentationConnectionCloseReason,
+    content::PresentationConnectionCloseReason> {
+  static media_router::mojom::MediaRouter::PresentationConnectionCloseReason
+  ToMojom(content::PresentationConnectionCloseReason reason) {
+    switch (reason) {
+      case content::PRESENTATION_CONNECTION_CLOSE_REASON_CONNECTION_ERROR:
+        return media_router::mojom::MediaRouter::
+            PresentationConnectionCloseReason::CONNECTION_ERROR;
+      case content::PRESENTATION_CONNECTION_CLOSE_REASON_CLOSED:
+        return media_router::mojom::MediaRouter::
+            PresentationConnectionCloseReason::CLOSED;
+      case content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY:
+        return media_router::mojom::MediaRouter::
+            PresentationConnectionCloseReason::WENT_AWAY;
+    }
+    NOTREACHED() << "Unknown PresentationConnectionCloseReason "
+                 << static_cast<int>(reason);
+    return media_router::mojom::MediaRouter::PresentationConnectionCloseReason::
+        CONNECTION_ERROR;
+  }
+
+  static bool FromMojom(
+      media_router::mojom::MediaRouter::PresentationConnectionCloseReason input,
+      content::PresentationConnectionCloseReason* state) {
+    switch (input) {
+      case media_router::mojom::MediaRouter::PresentationConnectionCloseReason::
+          CONNECTION_ERROR:
+        *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_CONNECTION_ERROR;
+        return true;
+      case media_router::mojom::MediaRouter::PresentationConnectionCloseReason::
+          CLOSED:
+        *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_CLOSED;
+        return true;
+      case media_router::mojom::MediaRouter::PresentationConnectionCloseReason::
+          WENT_AWAY:
+        *state = content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
+        return true;
+    }
+    return false;
+  }
+};
+
+// RouteRequestResultCode
+
+template <>
+struct EnumTraits<media_router::mojom::RouteRequestResultCode,
+                  media_router::RouteRequestResult::ResultCode> {
+  static media_router::mojom::RouteRequestResultCode ToMojom(
+      media_router::RouteRequestResult::ResultCode code) {
+    switch (code) {
+      case media_router::RouteRequestResult::UNKNOWN_ERROR:
+        return media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR;
+      case media_router::RouteRequestResult::OK:
+        return media_router::mojom::RouteRequestResultCode::OK;
+      case media_router::RouteRequestResult::TIMED_OUT:
+        return media_router::mojom::RouteRequestResultCode::TIMED_OUT;
+      case media_router::RouteRequestResult::ROUTE_NOT_FOUND:
+        return media_router::mojom::RouteRequestResultCode::ROUTE_NOT_FOUND;
+      case media_router::RouteRequestResult::SINK_NOT_FOUND:
+        return media_router::mojom::RouteRequestResultCode::SINK_NOT_FOUND;
+      case media_router::RouteRequestResult::INVALID_ORIGIN:
+        return media_router::mojom::RouteRequestResultCode::INVALID_ORIGIN;
+      case media_router::RouteRequestResult::INCOGNITO_MISMATCH:
+        return media_router::mojom::RouteRequestResultCode::INCOGNITO_MISMATCH;
+      case media_router::RouteRequestResult::NO_SUPPORTED_PROVIDER:
+        return media_router::mojom::RouteRequestResultCode::
+            NO_SUPPORTED_PROVIDER;
+      case media_router::RouteRequestResult::CANCELLED:
+        return media_router::mojom::RouteRequestResultCode::CANCELLED;
+      default:
+        NOTREACHED() << "Unknown RouteRequestResultCode "
+                     << static_cast<int>(code);
+        return media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR;
+    }
+  }
+
+  static bool FromMojom(media_router::mojom::RouteRequestResultCode input,
+                        media_router::RouteRequestResult::ResultCode* output) {
+    switch (input) {
+      case media_router::mojom::RouteRequestResultCode::UNKNOWN_ERROR:
+        *output = media_router::RouteRequestResult::UNKNOWN_ERROR;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::OK:
+        *output = media_router::RouteRequestResult::OK;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::TIMED_OUT:
+        *output = media_router::RouteRequestResult::TIMED_OUT;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::ROUTE_NOT_FOUND:
+        *output = media_router::RouteRequestResult::ROUTE_NOT_FOUND;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::SINK_NOT_FOUND:
+        *output = media_router::RouteRequestResult::SINK_NOT_FOUND;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::INVALID_ORIGIN:
+        *output = media_router::RouteRequestResult::INVALID_ORIGIN;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::INCOGNITO_MISMATCH:
+        *output = media_router::RouteRequestResult::INCOGNITO_MISMATCH;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::NO_SUPPORTED_PROVIDER:
+        *output = media_router::RouteRequestResult::NO_SUPPORTED_PROVIDER;
+        return true;
+      case media_router::mojom::RouteRequestResultCode::CANCELLED:
+        *output = media_router::RouteRequestResult::CANCELLED;
+        return true;
+    }
+    return false;
+  }
+};
+
 }  // namespace mojo
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_STRUCT_TRAITS_H_