WebSocket Pepper API: Add unit test to call Close()

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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 194 matching lines @@
                                   PP_CompletionCallback callback) {
   // Check mandarory interfaces.
   if (!websocket_.get())
     return PP_ERROR_FAILED;
 
   // Validate |code|.
   if (code != WebSocket::CloseEventCodeNotSpecified) {
     if (!(code == WebSocket::CloseEventCodeNormalClosure ||
         (WebSocket::CloseEventCodeMinimumUserDefined <= code &&
         code <= WebSocket::CloseEventCodeMaximumUserDefined)))
+    // RFC 6455 limits applications to use reserved connection close code in
+    // section 7.4.2.. The WebSocket API (http://www.w3.org/TR/websockets/)
+    // defines this out of range error as InvalidAccessError in JavaScript.
     return PP_ERROR_NOACCESS;
   }
 
   // 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)
     return PP_ERROR_INPROGRESS;
 
   // Validate |callback| (Doesn't support blocking callback)
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   // Install |callback|.
   close_callback_ = callback;
 
+  // Abort ongoing connect.
   if (state_ == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV) {
     state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
     PP_RunAndClearCompletionCallback(&connect_callback_, PP_ERROR_ABORTED);
     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;
+    PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_ABORTED);
+  }
+
   // Close connection.
   state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
   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)
     return PP_ERROR_BADARGUMENT;
 
   // Just return received message if any received message is queued.
   if (!received_messages_.empty())
     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;
 
   // 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|.
@@ skipping 133 matching lines @@
   // Records the error, then stops receiving any frames after this error.
   // The error will be notified after all queued messages are read via
   // ReceiveMessage().
   error_was_received_ = true;
   if (!wait_for_receive_)
     return;
 
   // 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;
   PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_FAILED);
 }
 
 void PPB_WebSocket_Impl::didUpdateBufferedAmount(
     unsigned long buffered_amount) {
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV)
     return;
   buffered_amount_ = buffered_amount;
 }
 
@@ skipping 20 matching lines @@
 
   // 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;
 
   if (state == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
-    PP_RunAndClearCompletionCallback(&connect_callback_, PP_OK);
+    PP_RunAndClearCompletionCallback(&connect_callback_, PP_ERROR_FAILED);
+
+  if (wait_for_receive_) {
+    wait_for_receive_ = false;
+    receive_callback_var_ = NULL;
+    PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_ABORTED);
+  }
 
   if (state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV)
     PP_RunAndClearCompletionCallback(&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();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit