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)))
     return PP_ERROR_NOACCESS;

[dmichael (off chromium), 2011/12/06 17:07:34]

This should probably be PP_ERROR_BADARGUMENT.

PP_ERROR_NOACCESS is for insufficient privileges, such as trying to fetch
something from a different origin using URLLoader.

[Takashi Toyoshima, 2011/12/06 17:47:18]

WebSocket protocol spec forbid applications to use these region of error code
because of they are reserved for lower layers. In other words, application layer
lacks privilege level to access these codes. That's why Yuzo-san and I decided
to return PP_ERROR_NOACCESS here.

[dmichael (off chromium), 2011/12/06 17:59:01]

Can you add a comment referencing that?

[Takashi Toyoshima, 2011/12/06 18:27:27]

Done.

   }
 
   // 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