[Presentation API] Mojo typemap for content::PresentationConnectionMessage

content/renderer/presentation/presentation_dispatcher.cc

 // Copyright 2015 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.
 
 #include "content/renderer/presentation/presentation_dispatcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/public/common/presentation_constants.h"
+#include "content/public/common/presentation_connection_message.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/presentation/presentation_connection_proxy.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationConnection.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationConnectionCallbacks.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
@@ skipping 128 matching lines @@
     const blink::WebString& message,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   if (message.utf8().size() > kMaxPresentationConnectionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
     LOG(WARNING) << "message size exceeded limit!";
     return;
   }
 
-  message_request_queue_.push_back(
-      base::WrapUnique(CreateSendTextMessageRequest(
-          presentationUrl, presentationId, message, connection_proxy)));
+  message_request_queue_.push_back(CreateSendTextMessageRequest(
+      presentationUrl, presentationId, message, connection_proxy));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
     DoSendMessage(message_request_queue_.front().get());
 }
 
 void PresentationDispatcher::sendArrayBuffer(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationConnectionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
-  message_request_queue_.push_back(
-      base::WrapUnique(CreateSendBinaryMessageRequest(
-          presentationUrl, presentationId,
-          blink::mojom::PresentationMessageType::BINARY, data, length,
-          connection_proxy)));
+  message_request_queue_.push_back(CreateSendBinaryMessageRequest(
+      presentationUrl, presentationId, data, length, connection_proxy));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
     DoSendMessage(message_request_queue_.front().get());
 }
 
 void PresentationDispatcher::sendBlobData(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationConnectionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
-  message_request_queue_.push_back(
-      base::WrapUnique(CreateSendBinaryMessageRequest(
-          presentationUrl, presentationId,
-          blink::mojom::PresentationMessageType::BINARY, data, length,
-          connection_proxy)));
+  message_request_queue_.push_back(CreateSendBinaryMessageRequest(
+      presentationUrl, presentationId, data, length, connection_proxy));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
     DoSendMessage(message_request_queue_.front().get());
 }
 
 void PresentationDispatcher::DoSendMessage(SendMessageRequest* request) {
   DCHECK(request->connection_proxy);
   // TODO(crbug.com/684116): Remove static_cast after moving message queue logic
   // from PresentationDispatcher to PresentationConnectionProxy.
   static_cast<const PresentationConnectionProxy*>(request->connection_proxy)
@@ skipping 377 matching lines @@
   controller_->didCloseConnection(
       blink::WebPresentationSessionInfo(
           session_info.presentation_url,
           blink::WebString::fromUTF8(session_info.presentation_id)),
       GetWebPresentationConnectionCloseReason(reason),
       blink::WebString::fromUTF8(message));
 }
 
 void PresentationDispatcher::OnConnectionMessagesReceived(
     const PresentationSessionInfo& session_info,
-    std::vector<blink::mojom::ConnectionMessagePtr> messages) {
+    std::vector<PresentationConnectionMessage> messages) {
   if (!controller_)
     return;
 
   for (size_t i = 0; i < messages.size(); ++i) {
     // Note: Passing batches of messages to the Blink layer would be more
     // efficient.
     auto web_session_info = blink::WebPresentationSessionInfo(
         session_info.presentation_url,
         blink::WebString::fromUTF8(session_info.presentation_id));
 
-    switch (messages[i]->type) {
-      case blink::mojom::PresentationMessageType::TEXT: {
-        // TODO(mfoltz): Do we need to DCHECK(messages[i]->message)?
-        controller_->didReceiveSessionTextMessage(
-            web_session_info,
-            blink::WebString::fromUTF8(messages[i]->message.value()));
-        break;
-      }
-      case blink::mojom::PresentationMessageType::BINARY: {
-        // TODO(mfoltz): Do we need to DCHECK(messages[i]->data)?
-        controller_->didReceiveSessionBinaryMessage(
-            web_session_info, &(messages[i]->data->front()),
-            messages[i]->data->size());
-        break;
-      }
-      default: {
-        NOTREACHED();
-        break;
-      }
+    if (messages[i].is_binary()) {
+      controller_->didReceiveSessionBinaryMessage(web_session_info,
+                                                  &(messages[i].data->front()),
+                                                  messages[i].data->size());
+    } else {
+      DCHECK(messages[i].message);
+      controller_->didReceiveSessionTextMessage(
+          web_session_info, blink::WebString::fromUTF8(*messages[i].message));
     }
   }
 }
 
 void PresentationDispatcher::ConnectToPresentationServiceIfNeeded() {
   if (presentation_service_.get())
     return;
 
   render_frame()->GetRemoteInterfaces()->GetInterface(&presentation_service_);
   presentation_service_->SetClient(binding_.CreateInterfacePtrAndBind());
@@ skipping 93 matching lines @@
         status ? status->last_known_availability : ScreenAvailability::UNKNOWN;
     current_availability =
         std::max(current_availability, static_cast<int>(screen_availability));
   }
 
   return static_cast<ScreenAvailability>(current_availability);
 }
 
 PresentationDispatcher::SendMessageRequest::SendMessageRequest(
     const PresentationSessionInfo& session_info,
-    blink::mojom::ConnectionMessagePtr message,
+    PresentationConnectionMessage connection_message,
     const blink::WebPresentationConnectionProxy* connection_proxy)
     : session_info(session_info),
-      message(std::move(message)),
+      message(std::move(connection_message)),
       connection_proxy(connection_proxy) {}
 
 PresentationDispatcher::SendMessageRequest::~SendMessageRequest() {}
 
 // static
-PresentationDispatcher::SendMessageRequest*
+std::unique_ptr<PresentationDispatcher::SendMessageRequest>
 PresentationDispatcher::CreateSendTextMessageRequest(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   PresentationSessionInfo session_info(GURL(presentationUrl),
                                        presentationId.utf8());
 
-  blink::mojom::ConnectionMessagePtr session_message =
-      blink::mojom::ConnectionMessage::New();
-  session_message->type = blink::mojom::PresentationMessageType::TEXT;
-  session_message->message = message.utf8();
-  return new SendMessageRequest(session_info, std::move(session_message),
-                                connection_proxy);
+  return base::MakeUnique<SendMessageRequest>(
+      session_info, PresentationConnectionMessage(message.utf8()),
+      connection_proxy);
 }
 
 // static
-PresentationDispatcher::SendMessageRequest*
+std::unique_ptr<PresentationDispatcher::SendMessageRequest>
 PresentationDispatcher::CreateSendBinaryMessageRequest(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
-    blink::mojom::PresentationMessageType type,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   PresentationSessionInfo session_info(GURL(presentationUrl),
                                        presentationId.utf8());
-
-  blink::mojom::ConnectionMessagePtr session_message =
-      blink::mojom::ConnectionMessage::New();
-  session_message->type = type;
-  session_message->data = std::vector<uint8_t>(data, data + length);
-  return new SendMessageRequest(session_info, std::move(session_message),
-                                connection_proxy);
+  return base::MakeUnique<SendMessageRequest>(
+      session_info,
+      PresentationConnectionMessage(std::vector<uint8_t>(data, data + length)),
+      connection_proxy);
 }
 
 PresentationDispatcher::AvailabilityListener::AvailabilityListener(
     const std::vector<GURL>& availability_urls)
     : urls(availability_urls) {}
 
 PresentationDispatcher::AvailabilityListener::~AvailabilityListener() {}
 
 PresentationDispatcher::ListeningStatus::ListeningStatus(
     const GURL& availability_url)
     : url(availability_url),
       last_known_availability(ScreenAvailability::UNKNOWN),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::ListeningStatus::~ListeningStatus() {}
 
 }  // namespace content