[PresentationAPI] Implements send API for Blob data from WebPresentationClient

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 "base/logging.h"
 #include "content/common/presentation/presentation_service.mojom.h"
 #include "content/public/common/presentation_constants.h"
 #include "content/public/common/service_registry.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/presentation/presentation_session_client.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationError.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
+using presentation::PresentationMessageType;
+
 namespace {
 
 blink::WebPresentationError::ErrorType GetWebPresentationErrorTypeFromMojo(
     presentation::PresentationErrorType mojoErrorType) {
   switch (mojoErrorType) {
     case presentation::PRESENTATION_ERROR_TYPE_NO_AVAILABLE_SCREENS:
       return blink::WebPresentationError::ErrorTypeNoAvailableScreens;
     case presentation::PRESENTATION_ERROR_TYPE_SESSION_REQUEST_CANCELLED:
       return blink::WebPresentationError::ErrorTypeSessionRequestCancelled;
     case presentation::PRESENTATION_ERROR_TYPE_NO_PRESENTATION_FOUND:
@@ skipping 17 matching lines @@
   return blink::WebPresentationSessionState::Disconnected;
 }
 
 GURL GetPresentationURLFromFrame(content::RenderFrame* frame) {
   DCHECK(frame);
 
   GURL url(frame->GetWebFrame()->document().defaultPresentationURL());
   return url.is_valid() ? url : GURL();
 }
 
+presentation::SessionMessage* GetMojoSessionMessage(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    PresentationMessageType type,
+    const uint8* data,
+    size_t length) {
+  presentation::SessionMessage* session_message =
+      new presentation::SessionMessage();
+  session_message->presentation_url = presentationUrl.utf8();
+  session_message->presentation_id = presentationId.utf8();
+  session_message->type = type;
+  const std::vector<uint8> vector(data, data + length);
+  session_message->data = mojo::Array<uint8>::From(vector);
+  return session_message;
+}
+
 }  // namespace
 
 namespace content {
 
 PresentationDispatcher::PresentationDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       controller_(nullptr),
       binding_(this) {
 }
 
@@ skipping 66 matching lines @@
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
     LOG(WARNING) << "message size exceeded limit!";
     return;
   }
 
   presentation::SessionMessage* session_message =
       new presentation::SessionMessage();
   session_message->presentation_url = presentationUrl.utf8();
   session_message->presentation_id = presentationId.utf8();
-  session_message->type = presentation::PresentationMessageType::
-                          PRESENTATION_MESSAGE_TYPE_TEXT;
+  session_message->type =
+      PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT;
   session_message->message = message.utf8();
 
   message_request_queue_.push(make_linked_ptr(session_message));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1) {
     const linked_ptr<presentation::SessionMessage>& request =
         message_request_queue_.front();
     DoSendMessage(*request);
   }
 }
 
 void PresentationDispatcher::sendArrayBuffer(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     const uint8* data,
     size_t length) {
   DCHECK(data);
   if (length > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
-  const std::vector<uint8> vector(data, data + length);
   presentation::SessionMessage* session_message =
-      new presentation::SessionMessage();
-  session_message->presentation_url = presentationUrl.utf8();
-  session_message->presentation_id = presentationId.utf8();
-  session_message->type = presentation::PresentationMessageType::
-                          PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
-  session_message->data = mojo::Array<uint8>::From(vector);
-
+      GetMojoSessionMessage(presentationUrl, presentationId,
+                            PresentationMessageType::
+                                PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER,
+                            data, length);
   message_request_queue_.push(make_linked_ptr(session_message));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1) {
     const linked_ptr<presentation::SessionMessage>& request =
         message_request_queue_.front();
     DoSendMessage(*request);
   }
 }
 
+void PresentationDispatcher::sendBlobData(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    const uint8* data,
+    size_t length) {
+  DCHECK(data);
+  if (length > kMaxPresentationSessionMessageSize) {
+    // TODO(crbug.com/459008): Same as in sendString().
+    LOG(WARNING) << "data size exceeded limit!";
+    return;
+  }
+
+  presentation::SessionMessage* session_message = GetMojoSessionMessage(
+      presentationUrl, presentationId,
+      PresentationMessageType::PRESENTATION_MESSAGE_TYPE_BLOB,
+      data, length);
+  message_request_queue_.push(make_linked_ptr(session_message));
+  if (message_request_queue_.size() == 1) {
+    const linked_ptr<presentation::SessionMessage>& request =
+        message_request_queue_.front();
+    DoSendMessage(*request);
+  }
+}
+
 void PresentationDispatcher::DoSendMessage(
     const presentation::SessionMessage& session_message) {
   ConnectToPresentationServiceIfNeeded();
-
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->presentation_url = session_message.presentation_url;
   message_request->presentation_id = session_message.presentation_id;
   message_request->type = session_message.type;
-  if (session_message.type == presentation::PresentationMessageType::
-                              PRESENTATION_MESSAGE_TYPE_TEXT) {
-    message_request->message = session_message.message;
-  } else if (session_message.type == presentation::PresentationMessageType::
-                                      PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER) {
-    message_request->data = mojo::Array<uint8>::From(
-        session_message.data.storage());
+  switch (session_message.type) {
+    case PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT: {
+      message_request->message = session_message.message;
+      break;
+    }
+    case PresentationMessageType::PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER:
+    case PresentationMessageType::PRESENTATION_MESSAGE_TYPE_BLOB: {
+      message_request->data =
+          mojo::Array<uint8>::From(session_message.data.storage());
+      break;
+    }
+    default: {
+      NOTREACHED() << "Invalid presentation message type "
+                   << session_message.type;
+      break;
+    }
   }
 
   presentation_service_->SendSessionMessage(
       message_request.Pass(),
       base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
                  base::Unretained(this)));
 }
 
 void PresentationDispatcher::HandleSendMessageRequests(bool success) {
   // In normal cases, message_request_queue_ should not be empty at this point
@@ skipping 104 matching lines @@
 }
 
 void PresentationDispatcher::OnSessionMessagesReceived(
     mojo::Array<presentation::SessionMessagePtr> messages) {
   // When messages is null, there is an error at presentation service side.
   if (!controller_ || messages.is_null())
     return;
 
   for (size_t i = 0; i < messages.size(); ++i) {
     if (messages[i]->type ==
-        presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT) {
+        PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT) {
       controller_->didReceiveSessionTextMessage(
           new PresentationSessionClient(messages[i]->presentation_url,
                                         messages[i]->presentation_id),
           blink::WebString::fromUTF8(messages[i]->message));
     } else {
       // TODO(haibinlu): handle binary message
     }
   }
 
   presentation_service_->ListenForSessionMessages(
@@ skipping 20 matching lines @@
   presentation_service_->ListenForSessionStateChange(base::Bind(
       &PresentationDispatcher::OnSessionStateChange,
       base::Unretained(this)));
   presentation_service_->ListenForSessionMessages(
       base::Bind(&PresentationDispatcher::OnSessionMessagesReceived,
       base::Unretained(this)));
   */
 }
 
 }  // namespace content