WebSocket Pepper API: make the API out of dev

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"
@@ skipping 49 matching lines @@
 
 uint64_t GetFrameSize(uint64_t payload_size) {
   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 ||
-      state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
+bool InValidStateToReceive(PP_WebSocketReadyState state) {
+  return state == PP_WEBSOCKETREADYSTATE_OPEN ||
+      state == PP_WEBSOCKETREADYSTATE_CLOSING;
 }
 
 }  // namespace
 
 namespace webkit {
 namespace ppapi {
 
 PPB_WebSocket_Impl::PPB_WebSocket_Impl(PP_Instance instance)
     : Resource(instance),
-      state_(PP_WEBSOCKETREADYSTATE_INVALID_DEV),
-      binary_type_(WebSocket::BinaryTypeBlob),
+      state_(PP_WEBSOCKETREADYSTATE_INVALID),
       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) {
 }
 
@@ skipping 18 matching lines @@
                                     PP_CompletionCallback callback) {
   // Check mandatory interfaces.
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   DCHECK(plugin_instance);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
 
   // Connect() can be called at most once.
   if (websocket_.get())
     return PP_ERROR_INPROGRESS;
-  if (state_ != PP_WEBSOCKETREADYSTATE_INVALID_DEV)
+  if (state_ != PP_WEBSOCKETREADYSTATE_INVALID)
     return PP_ERROR_INPROGRESS;
-  state_ = PP_WEBSOCKETREADYSTATE_CLOSED_DEV;
+  state_ = PP_WEBSOCKETREADYSTATE_CLOSED;
 
   // Validate url and convert it to WebURL.
   scoped_refptr<StringVar> url_string = StringVar::FromPPVar(url);
   if (!url_string)
     return PP_ERROR_BADARGUMENT;
   GURL gurl(url_string->value());
   url_ = new StringVar(gurl.spec());
   if (!gurl.is_valid())
     return PP_ERROR_BADARGUMENT;
   if (!gurl.SchemeIs("ws") && !gurl.SchemeIs("wss"))
@@ skipping 54 matching lines @@
     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_->setBinaryType(WebSocket::BinaryTypeArrayBuffer);
 
   websocket_->connect(web_url, web_protocols);
-  state_ = PP_WEBSOCKETREADYSTATE_CONNECTING_DEV;
+  state_ = PP_WEBSOCKETREADYSTATE_CONNECTING;
 
   // Install callback.
   connect_callback_ = new TrackedCallback(this, callback);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_WebSocket_Impl::Close(uint16_t code,
                                   PP_Var reason,
                                   PP_CompletionCallback callback) {
@@ skipping 14 matching lines @@
   }
 
   // Validate |reason|.
   // TODO(toyoshim): Returns PP_ERROR_BADARGUMENT if |reason| contains any
   // surrogates.
   scoped_refptr<StringVar> reason_string = StringVar::FromPPVar(reason);
   if (!reason_string || reason_string->value().size() > kMaxReasonSizeInBytes)
     return PP_ERROR_BADARGUMENT;
 
   // Check state.
-  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV ||
-      state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV)
+  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING ||
+      state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
     return PP_ERROR_INPROGRESS;
 
   // Validate |callback| (Doesn't support blocking callback)
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   // Install |callback|.
   close_callback_ = new TrackedCallback(this, callback);
 
   // Abort ongoing connect.
-  if (state_ == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV) {
-    state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
+  if (state_ == PP_WEBSOCKETREADYSTATE_CONNECTING) {
+    state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
     // Need to do a "Post" to avoid reentering the plugin.
     connect_callback_->PostAbort();
     connect_callback_ = NULL;
     websocket_->fail(
         "WebSocket was closed before the connection was established.");
     return PP_OK_COMPLETIONPENDING;
   }
 
   // Abort ongoing receive.
   if (wait_for_receive_) {
     wait_for_receive_ = false;
     receive_callback_var_ = NULL;
 
     // Need to do a "Post" to avoid reentering the plugin.
     receive_callback_->PostAbort();
     receive_callback_ = NULL;
   }
 
   // Close connection.
-  state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
+  state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
   WebString web_reason = WebString::fromUTF8(reason_string->value());
   websocket_->close(code, web_reason);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 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)
+  if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
+      state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
     return PP_ERROR_BADARGUMENT;
 
   // Just return received message if any received message is queued.
   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)
+  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
     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;
 
   // Validate |callback| (Doesn't support blocking callback)
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   // Or retain |message| as buffer to store and install |callback|.
   wait_for_receive_ = true;
   receive_callback_var_ = message;
   receive_callback_ = new TrackedCallback(this, callback);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_WebSocket_Impl::SendMessage(PP_Var message) {
   // Check mandatory interfaces.
   if (!websocket_.get())
     return PP_ERROR_FAILED;
 
   // Check state.
-  if (state_ == PP_WEBSOCKETREADYSTATE_INVALID_DEV ||
-      state_ == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
+  if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
+      state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
     return PP_ERROR_BADARGUMENT;
 
-  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV ||
-      state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV) {
+  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING ||
+      state_ == PP_WEBSOCKETREADYSTATE_CLOSED) {
     // 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)
@@ skipping 63 matching lines @@
 
 PP_Var PPB_WebSocket_Impl::GetProtocol() {
   // Check mandatory interfaces.
   if (!websocket_.get())
     return empty_string_->GetPPVar();
 
   std::string protocol = websocket_->subprotocol().utf8();
   return StringVar::StringToPPVar(protocol);
 }
 
-PP_WebSocketReadyState_Dev PPB_WebSocket_Impl::GetReadyState() {
+PP_WebSocketReadyState PPB_WebSocket_Impl::GetReadyState() {
   return state_;
 }
 
 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) {
-  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;
-  }
-  // WebKit API setBinaryType() is called when Connect() is called.
-  // If the websocket_ contains an object; it means Connect() is already
-  // called, call WebKit API here to reflect the setting as soon as possible.
-  if (websocket_.get())
-    websocket_->setBinaryType(binary_type_);
-  return PP_TRUE;
-}
-
-PP_WebSocketBinaryType_Dev PPB_WebSocket_Impl::GetBinaryType() {
-  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;
+  DCHECK_EQ(PP_WEBSOCKETREADYSTATE_CONNECTING, state_);
+  state_ = PP_WEBSOCKETREADYSTATE_OPEN;
   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();
@@ skipping 35 matching lines @@
 
   // But, if no messages are queued and ReceiveMessage() is now on going.
   // We must invoke the callback with error code here.
   wait_for_receive_ = false;
   receive_callback_var_ = NULL;
   TrackedCallback::ClearAndRun(&receive_callback_, PP_ERROR_FAILED);
 }
 
 void PPB_WebSocket_Impl::didUpdateBufferedAmount(
     unsigned long buffered_amount) {
-  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV)
+  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
     return;
   buffered_amount_ = buffered_amount;
 }
 
 void PPB_WebSocket_Impl::didStartClosingHandshake() {
-  state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
+  state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
 }
 
 void PPB_WebSocket_Impl::didClose(unsigned long unhandled_buffered_amount,
                                   ClosingHandshakeCompletionStatus status,
                                   unsigned short code,
                                   const WebString& reason) {
   // Store code and reason.
   close_code_ = code;
   std::string reason_string = reason.utf8();
   close_reason_ = new StringVar(reason_string);
 
   // Set close_was_clean_.
   bool was_clean =
-      state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV &&
+      state_ == PP_WEBSOCKETREADYSTATE_CLOSING &&
       !unhandled_buffered_amount &&
       status == WebSocketClient::ClosingHandshakeComplete;
   close_was_clean_ = was_clean ? PP_TRUE : PP_FALSE;
 
   // Update buffered_amount_.
   buffered_amount_ = unhandled_buffered_amount;
 
   // Handle state transition and invoking callback.
-  DCHECK_NE(PP_WEBSOCKETREADYSTATE_CLOSED_DEV, state_);
-  PP_WebSocketReadyState_Dev state = state_;
-  state_ = PP_WEBSOCKETREADYSTATE_CLOSED_DEV;
+  DCHECK_NE(PP_WEBSOCKETREADYSTATE_CLOSED, state_);
+  PP_WebSocketReadyState state = state_;
+  state_ = PP_WEBSOCKETREADYSTATE_CLOSED;
 
-  if (state == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
+  if (state == PP_WEBSOCKETREADYSTATE_CONNECTING)
     TrackedCallback::ClearAndRun(&connect_callback_, PP_ERROR_FAILED);
 
   if (wait_for_receive_) {
     wait_for_receive_ = false;
     receive_callback_var_ = NULL;
     TrackedCallback::ClearAndAbort(&receive_callback_);
   }
 
-  if (state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV)
+  if (state == PP_WEBSOCKETREADYSTATE_CLOSING)
     TrackedCallback::ClearAndRun(&close_callback_, PP_OK);
 
   // 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()->GetPPVar();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit