[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..6d7fc7e23d8bf45da5a6623e9c92d45f8012a34c 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();
+  }
+
+  static base::Optional<std::string> domain(
+      const media_router::MediaSink& sink) {
+    return 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) {
+    // Currently we are not converting MediaRoute from C++ to Mojo.
+    NOTREACHED();

[mark a. foltz, 2017/02/09 22:53:52]

It seems like you've written a typemap anyway; remove this?

[dcheng, 2017/02/10 10:30:56]

This was at my request: ideally, we want the mojo getters to be very thin and
just return references to data, which this is not doing. Since this isn't used
ATM (though the typemap requires that it be present), I asked to NOTREACHED()
here so we can fix it up if we start using it.

+    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;

[mark a. foltz, 2017/02/09 22:53:52]

It's unfortunate we have duplicate definitions of PresentationConnectionState in
mojom.  Pending resolution of the ongoing design discussion, we should factor
out a separate mojom for this enum.

+    }
+    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:

[mark a. foltz, 2017/02/09 22:53:52]

Similar comment applies to PresentationConnectionCloseReason.

+        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_