[Presentation API] Mojo typemap for content::PresentationConnectionMessage

content/common/presentation/presentation_struct_traits.h

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_COMMON_PRESENTATION_PRESENTATION_STRUCT_TRAITS_H_
 #define CONTENT_COMMON_PRESENTATION_PRESENTATION_STRUCT_TRAITS_H_
 
 #include <string>
+#include <vector>
 
 #include "base/macros.h"
+#include "base/optional.h"
 #include "base/strings/string_util.h"
+#include "content/public/common/presentation_connection_message.h"
 #include "content/public/common/presentation_session.h"
-#include "mojo/common/common_custom_types_struct_traits.h"
 #include "third_party/WebKit/public/platform/modules/presentation/presentation.mojom.h"
 #include "url/mojo/url.mojom.h"
 
 namespace mojo {
 
 template <>
 struct EnumTraits<blink::mojom::PresentationErrorType,
                   content::PresentationErrorType> {
   static blink::mojom::PresentationErrorType ToMojom(
       content::PresentationErrorType input) {
@@ skipping 120 matching lines @@
   static const GURL& url(const content::PresentationSessionInfo& session_info) {
     return session_info.presentation_url;
   }
 
   static const std::string& id(
       const content::PresentationSessionInfo& session_info) {
     return session_info.presentation_id;
   }
 
   static bool Read(blink::mojom::PresentationSessionInfoDataView data,
-                   content::PresentationSessionInfo* out) {
-    if (!data.ReadUrl(&(out->presentation_url)))
-      return false;
-
-    if (!data.ReadId(&(out->presentation_id)))
-      return false;
-
-    if (out->presentation_id.empty() ||
-        !base::IsStringASCII(out->presentation_id) ||
-        out->presentation_id.length() >
-            content::PresentationSessionInfo::kMaxIdLength) {
-      return false;
-    }
-
-    return true;
-  }
+                   content::PresentationSessionInfo* out);
 };
 
 template <>
 struct StructTraits<blink::mojom::PresentationErrorDataView,
                     content::PresentationError> {
   static content::PresentationErrorType error_type(
       const content::PresentationError& error) {
     return error.error_type;
   }
 
   static const std::string& message(const content::PresentationError& error) {
     return error.message;
   }
 
   static bool Read(blink::mojom::PresentationErrorDataView data,
-                   content::PresentationError* out) {
-    if (!data.ReadErrorType(&(out->error_type)))
-      return false;
+                   content::PresentationError* out);
+};
 
-    if (!data.ReadMessage(&(out->message)))
-      return false;
+template <>
+struct UnionTraits<blink::mojom::PresentationConnectionMessageDataView,
+                   content::PresentationConnectionMessage> {
+  static blink::mojom::PresentationConnectionMessageDataView::Tag GetTag(
+      const content::PresentationConnectionMessage& message) {
+    return message.is_binary()
+               ? blink::mojom::PresentationConnectionMessageDataView::Tag::DATA
+               : blink::mojom::PresentationConnectionMessageDataView::Tag::
+                     MESSAGE;
+  }
 
-    if (!base::IsStringUTF8(out->message) ||
-        out->message.length() > content::PresentationError::kMaxMessageLength)
-      return false;
+  static const std::string& message(
+      const content::PresentationConnectionMessage& message) {
+    DCHECK(!message.is_binary());
+    return message.message.value();
+  }
 
-    return true;
+  static const std::vector<uint8_t>& data(
+      const content::PresentationConnectionMessage& message) {
+    DCHECK(message.is_binary());
+    return message.data.value();
   }
+
+  static bool Read(blink::mojom::PresentationConnectionMessageDataView data,
+                   content::PresentationConnectionMessage* out);
 };
 
 }  // namespace mojo
 
 #endif  // CONTENT_COMMON_PRESENTATION_PRESENTATION_STRUCT_TRAITS_H_