[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 149 matching lines @@
     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(base::WrapUnique(CreateSendBinaryMessageRequest(
-      presentationUrl, presentationId,
-      blink::mojom::PresentationMessageType::BINARY, data, length,
-      connection_proxy)));
+      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(base::WrapUnique(CreateSendBinaryMessageRequest(
-      presentationUrl, presentationId,
-      blink::mojom::PresentationMessageType::BINARY, data, length,
-      connection_proxy)));
+      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 352 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) {
+    const 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*
 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),
+  return new SendMessageRequest(session_info,

[dcheng, 2017/02/25 07:17:27]

Please add a TODO to make this and the function below return std::unique_ptr

[mark a. foltz, 2017/02/27 23:25:15]

Done.

+                                PresentationConnectionMessage(message.utf8()),
                                 connection_proxy);
 }
 
 // static
 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 new 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