WebSocket Pepper API: ArrayBuffer support

webkit/plugins/ppapi/ppb_websocket_impl.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/ppb_websocket_impl.h"
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
+#include "ppapi/c/dev/ppb_var_array_buffer_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSocket.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
+using ppapi::ArrayBufferVar;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::thunk::PPB_WebSocket_API;
 using ppapi::VarTracker;
 using WebKit::WebData;
 using WebKit::WebDocument;
 using WebKit::WebString;
 using WebKit::WebSocket;
 using WebKit::WebSocketClient;
 using WebKit::WebURL;
 
 const uint32_t kMaxReasonSizeInBytes = 123;
 const size_t kHybiBaseFramingOverhead = 2;
 const size_t kHybiMaskingKeyLength = 4;
 const size_t kMinimumPayloadSizeWithTwoByteExtendedPayloadLength = 126;
 const size_t kMinimumPayloadSizeWithEightByteExtendedPayloadLength = 0x10000;
 
 namespace {
 
 uint64_t SaturateAdd(uint64_t a, uint64_t b) {
   if (kuint64max - a < b)
     return kuint64max;
   return a + b;
 }
 
 uint64_t GetFrameSize(uint64_t payload_size) {
-  if (!payload_size)
-    return 0;
-
   uint64_t overhead = kHybiBaseFramingOverhead + kHybiMaskingKeyLength;
   if (payload_size > kMinimumPayloadSizeWithEightByteExtendedPayloadLength)
     overhead += 8;
   else if (payload_size > kMinimumPayloadSizeWithTwoByteExtendedPayloadLength)
     overhead += 2;
   return SaturateAdd(payload_size, overhead);
 }
 
 bool InValidStateToReceive(PP_WebSocketReadyState_Dev state) {
   return state == PP_WEBSOCKETREADYSTATE_OPEN_DEV ||
@@ skipping 207 matching lines @@
 }
 
 int32_t PPB_WebSocket_Impl::ReceiveMessage(PP_Var* message,
                                            PP_CompletionCallback callback) {
   // Check state.
   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID_DEV ||
       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
     return PP_ERROR_BADARGUMENT;
 
   // Just return received message if any received message is queued.
-  if (!received_messages_.empty())
+  if (!received_messages_.empty()) {
+    receive_callback_var_ = message;
     return DoReceive();
+  }
 
   // Check state again. In CLOSED state, no more messages will be received.
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV)
     return PP_ERROR_BADARGUMENT;
 
   // Returns PP_ERROR_FAILED after an error is received and received messages
   // is exhausted.
   if (error_was_received_)
     return PP_ERROR_FAILED;
 
@@ skipping 20 matching lines @@
     return PP_ERROR_BADARGUMENT;
 
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV ||
       state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV) {
     // Handle buffered_amount_after_close_.
     uint64_t payload_size = 0;
     if (message.type == PP_VARTYPE_STRING) {
       scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
       if (message_string)
         payload_size += message_string->value().length();
+    } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
+      scoped_refptr<ArrayBufferVar> message_array_buffer =
+          ArrayBufferVar::FromPPVar(message);
+      if (message_array_buffer)
+        payload_size += message_array_buffer->ByteLength();
+    } else {
+      // TODO(toyoshim): Support Blob.
+      return PP_ERROR_NOTSUPPORTED;
     }
-    // TODO(toyoshim): Support binary data.
 
     buffered_amount_after_close_ =
         SaturateAdd(buffered_amount_after_close_, GetFrameSize(payload_size));
 
     return PP_ERROR_FAILED;
   }
 
-  if (message.type != PP_VARTYPE_STRING) {
-    // TODO(toyoshim): Support binary data.
+  // Send the message.
+  if (message.type == PP_VARTYPE_STRING) {
+    // Convert message to WebString.
+    scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
+    if (!message_string)
+      return PP_ERROR_BADARGUMENT;
+    WebString web_message = WebString::fromUTF8(message_string->value());
+    if (!websocket_->sendText(web_message))
+      return PP_ERROR_BADARGUMENT;
+  } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
+    // Convert message to WebData.
+    // TODO(toyoshim): Must add a WebKit interface which handles WebArrayBuffer
+    // directly.
+    scoped_refptr<ArrayBufferVar> message_array_buffer =
+        ArrayBufferVar::FromPPVar(message);
+    if (!message_array_buffer)
+      return PP_ERROR_BADARGUMENT;
+    WebData web_message = WebData(
+        static_cast<const char*>(message_array_buffer->Map()),
+        static_cast<size_t>(message_array_buffer->ByteLength()));
+    if (!websocket_->sendBinary(web_message))
+      return PP_ERROR_BADARGUMENT;
+  } else {
+    // TODO(toyoshim): Support Blob.
     return PP_ERROR_NOTSUPPORTED;
   }
 
-  // Convert message to WebString.
-  scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
-  if (!message_string)
-    return PP_ERROR_BADARGUMENT;
-  WebString web_message = WebString::fromUTF8(message_string->value());
-  if (!websocket_->sendText(web_message))
-    return PP_ERROR_BADARGUMENT;
-
   return PP_OK;
 }
 
 uint64_t PPB_WebSocket_Impl::GetBufferedAmount() {
   return SaturateAdd(buffered_amount_, buffered_amount_after_close_);
 }
 
 uint16_t PPB_WebSocket_Impl::GetCloseCode() {
   return close_code_;
 }
@@ skipping 55 matching lines @@
     return;
 
   PP_RunAndClearCompletionCallback(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveBinaryData(const WebData& binaryData) {
   // Dispose packets after receiving an error or in invalid state.
   if (error_was_received_ || !InValidStateToReceive(state_))
     return;
 
-  // TODO(toyoshim): Support to receive binary data.
-  DLOG(INFO) << "didReceiveBinaryData is not implemented yet.";
+  // Append received data to queue.
+  PP_Var var = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
+      binaryData.size());
+  scoped_refptr<ArrayBufferVar> arraybuffer = ArrayBufferVar::FromPPVar(var);
+  void* data = arraybuffer->Map();
+  memcpy(data, binaryData.data(), binaryData.size());
+  received_messages_.push(var);
+
+  if (!wait_for_receive_)
+    return;
+
+  PP_RunAndClearCompletionCallback(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveMessageError() {
   // Ignore error notification in invalid state.
   if (!InValidStateToReceive(state_))
     return;
 
   // Records the error, then stops receiving any frames after this error.
   // The error will be notified after all queued messages are read via
   // ReceiveMessage().
@@ skipping 66 matching lines @@
 
   *receive_callback_var_ = received_messages_.front();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit