WebSocket Pepper API: WebArrayBuffer support

webkit/plugins/ppapi/ppb_websocket_impl.cc

 // Copyright (c) 2012 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/WebArrayBuffer.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_array_buffer_var.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::TrackedCallback;
+using ppapi::Var;
 using ppapi::VarTracker;
-using WebKit::WebData;
+using WebKit::WebArrayBuffer;
 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;
@@ skipping 19 matching lines @@
 bool InValidStateToReceive(PP_WebSocketReadyState_Dev state) {
   return state == PP_WEBSOCKETREADYSTATE_OPEN_DEV ||
       state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
 }
 
 }  // namespace
 
 namespace webkit {
 namespace ppapi {
 
-// TODO(toyoshim): Default value of binary_type_ must be
-// PP_WEBSOCKETBINARYTYPE_BLOB_DEV after supporting Blob.
 PPB_WebSocket_Impl::PPB_WebSocket_Impl(PP_Instance instance)
     : Resource(instance),
       state_(PP_WEBSOCKETREADYSTATE_INVALID_DEV),
-      binary_type_(PP_WEBSOCKETBINARYTYPE_ARRAYBUFFER_DEV),
+      binary_type_(WebSocket::BinaryTypeBlob),
       error_was_received_(false),
       receive_callback_var_(NULL),
       wait_for_receive_(false),
       close_code_(0),
       close_was_clean_(PP_FALSE),
       empty_string_(new StringVar("", 0)),
       buffered_amount_(0),
       buffered_amount_after_close_(0) {
 }
 
 PPB_WebSocket_Impl::~PPB_WebSocket_Impl() {
   if (websocket_.get())
     websocket_->disconnect();
-
-  // Clean up received and unread messages
-  VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
-  while (!received_messages_.empty()) {
-    PP_Var var = received_messages_.front();
-    received_messages_.pop();
-    var_tracker->ReleaseVar(var);
-  }
 }
 
 // static
 PP_Resource PPB_WebSocket_Impl::Create(PP_Instance instance) {
   scoped_refptr<PPB_WebSocket_Impl> ws(new PPB_WebSocket_Impl(instance));
   return ws->GetReference();
 }
 
 PPB_WebSocket_API* PPB_WebSocket_Impl::AsPPB_WebSocket_API() {
   return this;
@@ skipping 81 matching lines @@
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   // Create WebKit::WebSocket object and connect.
   WebDocument document = plugin_instance->container()->element().document();
   websocket_.reset(WebSocket::create(document, this));
   DCHECK(websocket_.get());
   if (!websocket_.get())
     return PP_ERROR_NOTSUPPORTED;
 
+  // Set receiving binary object type.
+  websocket_->setBinaryType(binary_type_);
+
   websocket_->connect(web_url, web_protocols);
   state_ = PP_WEBSOCKETREADYSTATE_CONNECTING_DEV;
 
   // Install callback.
   connect_callback_ = new TrackedCallback(this, callback);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_WebSocket_Impl::Close(uint16_t code,
@@ skipping 134 matching lines @@
   // 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)
+    // Convert message to WebArrayBuffer.
+    scoped_refptr<HostArrayBufferVar> host_message =
+        static_cast<HostArrayBufferVar*>(ArrayBufferVar::FromPPVar(message));
+    if (!host_message)
       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))
+    WebArrayBuffer& web_message = host_message->webkit_buffer();
+    if (!websocket_->sendArrayBuffer(web_message))
       return PP_ERROR_BADARGUMENT;
   } else {
     // TODO(toyoshim): Support Blob.
     return PP_ERROR_NOTSUPPORTED;
   }
 
   return PP_OK;
 }
 
 uint64_t PPB_WebSocket_Impl::GetBufferedAmount() {
@@ skipping 36 matching lines @@
 }
 
 PP_Var PPB_WebSocket_Impl::GetURL() {
   if (!url_)
     return empty_string_->GetPPVar();
   return url_->GetPPVar();
 }
 
 PP_Bool PPB_WebSocket_Impl::SetBinaryType(
     PP_WebSocketBinaryType_Dev binary_type) {
-  // TODO(toyoshim): Use WebKit new API to set the receiving binary type.
-  return PP_FALSE;
+  switch (binary_type) {
+    case PP_WEBSOCKETBINARYTYPE_BLOB_DEV:
+      binary_type_ = WebSocket::BinaryTypeBlob;
+      break;
+    case PP_WEBSOCKETBINARYTYPE_ARRAYBUFFER_DEV:
+      binary_type_ = WebSocket::BinaryTypeArrayBuffer;
+      break;
+    default:
+      return PP_FALSE;
+  }
+  if (!websocket_.get())
+    return PP_FALSE;
+  websocket_->setBinaryType(binary_type_);
+  return PP_TRUE;
 }
 
 PP_WebSocketBinaryType_Dev PPB_WebSocket_Impl::GetBinaryType() {
-  return binary_type_;
+  switch (binary_type_) {
+    case WebSocket::BinaryTypeBlob:
+      return PP_WEBSOCKETBINARYTYPE_BLOB_DEV;
+    case WebSocket::BinaryTypeArrayBuffer:
+      return PP_WEBSOCKETBINARYTYPE_ARRAYBUFFER_DEV;
+    default:
+      NOTREACHED();
+      return PP_WEBSOCKETBINARYTYPE_INVALID;
+  }
 }
 
 void PPB_WebSocket_Impl::didConnect() {
   DCHECK_EQ(PP_WEBSOCKETREADYSTATE_CONNECTING_DEV, state_);
   state_ = PP_WEBSOCKETREADYSTATE_OPEN_DEV;
   TrackedCallback::ClearAndRun(&connect_callback_, PP_OK);
 }
 
 void PPB_WebSocket_Impl::didReceiveMessage(const WebString& message) {
   // Dispose packets after receiving an error or in invalid state.
   if (error_was_received_ || !InValidStateToReceive(state_))
     return;
 
   // Append received data to queue.
   std::string string = message.utf8();
-  PP_Var var = StringVar::StringToPPVar(string);
-  received_messages_.push(var);
+  received_messages_.push(new scoped_refptr<Var>(new StringVar(string)));

[dmichael (off chromium), 2012/01/17 22:14:28]

You don't want to "new" the scoped_refptr; I think you're now leaking both the
Var and the scoped_refptr.

[Takashi Toyoshima, 2012/01/18 12:10:43]

This time, I misunderstand std::queue using with Class.
Now I think I understand correctly.

Here, copy constructor is used to store. In the case of scoped_refptr, reference
counting flips. Finally queue contains copied scoped_refptr having original
StringVar pointer with 1 reference count.

These are deleted or released at the time of queue's destruction.
Could I understand correctly?

[dmichael (off chromium), 2012/01/18 16:20:47]

Yep!

 
   if (!wait_for_receive_)
     return;
 
   TrackedCallback::ClearAndRun(&receive_callback_, DoReceive());
 }
 
-void PPB_WebSocket_Impl::didReceiveBinaryData(const WebData& binaryData) {
+void PPB_WebSocket_Impl::didReceiveArrayBuffer(
+    const WebArrayBuffer& binaryData) {
   // Dispose packets after receiving an error or in invalid state.
   if (error_was_received_ || !InValidStateToReceive(state_))
     return;
 
   // 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);
+  received_messages_.push(
+      new scoped_refptr<Var>(new HostArrayBufferVar(binaryData)));

[dmichael (off chromium), 2012/01/17 22:14:28]

Ditto

[Takashi Toyoshima, 2012/01/18 12:10:43]

Done.

 
   if (!wait_for_receive_)
     return;
 
   TrackedCallback::ClearAndRun(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveMessageError() {
   // Ignore error notification in invalid state.
   if (!InValidStateToReceive(state_))
@@ skipping 62 matching lines @@
 
   // Disconnect.
   if (websocket_.get())
     websocket_->disconnect();
 }
 
 int32_t PPB_WebSocket_Impl::DoReceive() {
   if (!receive_callback_var_)
     return PP_OK;
 
-  *receive_callback_var_ = received_messages_.front();
+  *receive_callback_var_ = (*received_messages_.front())->GetPPVar();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit