WebSocket Pepper API: error handling improvement

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 54 matching lines @@
 }
 
 }  // namespace
 
 namespace webkit {
 namespace ppapi {
 
 PPB_WebSocket_Impl::PPB_WebSocket_Impl(PP_Instance instance)
     : Resource(instance),
       state_(PP_WEBSOCKETREADYSTATE_INVALID_DEV),
+      error_was_received_(false),
       receive_callback_var_(NULL),
       wait_for_receive_(false),
       close_code_(0),
       close_was_clean_(PP_FALSE),
       buffered_amount_(0),
       buffered_amount_after_close_(0) {
   empty_string_ = new StringVar(
       PpapiGlobals::Get()->GetModuleForInstance(instance), "", 0);
 }
 
@@ skipping 158 matching lines @@
   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;

[dmichael (off chromium), 2011/12/01 17:09:34]

Whoops, shouldn't this function also check that the completion callback is not a
blocking one and return PP_ERROR_BLOCKS_MAIN_THREAD if it is?

[Takashi Toyoshima, 2011/12/02 05:51:28]

Oh, right!
I fix in the next change.

[dmichael (off chromium), 2011/12/02 16:28:08]

Okay. By the way, this one will be a little more subtle than the others. If
received_messages_ is non-empty, then you can still return DoReceive() (as you
have below). But if it's empty, that's when you need PP_ERROR_BLOCKS_MAIN_THREAD

[Takashi Toyoshima, 2011/12/02 17:15:42]

OK, I verify callbacks just before install them to variables.

 
   // Just return received message if any received message is queued.
   if (!received_messages_.empty())
     return DoReceive();

[dmichael (off chromium), 2011/12/02 16:28:08]

I just realized there's a problem here; you're not handling the
'PP_COMPLETIONCALLBACK_FLAG_OPTIONAL' flag, if the callback has one. When you
fix this to return PP_ERROR_BLOCKS_MAIN_THREAD when appropriate, please also fix
this to handle the force-async case.

To do so, you'll want to update the thunk layer and use 'MayForceCallback' (you
can grep for it in ppapi/thunk for examples).

[Takashi Toyoshima, 2011/12/02 17:15:42]

Oh, I see.
I fix it.

 
+  // Returns PP_ERROR_FAILED after an error is received and received messages
+  // is exhausted.
+  if (error_was_received_)
+    return PP_ERROR_FAILED;
+
   // Or retain |message| as buffer to store and install |callback|.
   wait_for_receive_ = true;
   receive_callback_var_ = message;
   receive_callback_ = callback;
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_WebSocket_Impl::SendMessage(PP_Var message) {
   // Check mandatory interfaces.
@@ skipping 84 matching lines @@
   return url_->GetPPVar();
 }
 
 void PPB_WebSocket_Impl::didConnect() {
   DCHECK_EQ(PP_WEBSOCKETREADYSTATE_CONNECTING_DEV, state_);
   state_ = PP_WEBSOCKETREADYSTATE_OPEN_DEV;
   PP_RunAndClearCompletionCallback(&connect_callback_, PP_OK);
 }
 
 void PPB_WebSocket_Impl::didReceiveMessage(const WebString& message) {
+  // Dispose packets after receiving an error.
+  if (error_was_received_)
+    return;
+
+  // Dispose packets in invalid state.
+  if (state_ != PP_WEBSOCKETREADYSTATE_OPEN_DEV &&
+      state_ != PP_WEBSOCKETREADYSTATE_CLOSING)

[dmichael (off chromium), 2011/12/01 17:09:34]

Shouldn't that be 'CLOSING_DEV'? In my local check-out, ppb_websocket_dev.h has
'PP_WEBSOCKETREADYSTATE_CLOSING_DEV'. 

[Takashi Toyoshima, 2011/12/02 05:51:28]

Yes!
Sorry, I missed compilation error?
Fixed.

+    return;
+
   // Append received data to queue.
   std::string string = message.utf8();
   PP_Var var = StringVar::StringToPPVar(
       PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), string);
   received_messages_.push(var);
 
   if (!wait_for_receive_)
     return;
 
   PP_RunAndClearCompletionCallback(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveBinaryData(const WebData& binaryData) {
+  // Dispose packets after receiving an error.
+  if (error_was_received_)
+    return;
+
+  // Dispose packets in invalid state.
+  if (state_ != PP_WEBSOCKETREADYSTATE_OPEN_DEV &&
+      state_ != PP_WEBSOCKETREADYSTATE_CLOSING)

[dmichael (off chromium), 2011/12/01 17:09:34]

optional suggestion: You do this check a lot. It could be worth a quick function
'InValidStateToReceive' or something.

[Takashi Toyoshima, 2011/12/02 05:51:28]

Sounds nice.
Done.

+    return;
+
+  // TODO(toyoshim): Support to receive binary data.
   DLOG(INFO) << "didReceiveBinaryData is not implemented yet.";
-  // TODO(toyoshim): Support to receive binary data.
 }
 
 void PPB_WebSocket_Impl::didReceiveMessageError() {
-  // TODO(toyoshim): Must implement.
-  DLOG(INFO) << "didReceiveMessageError is not implemented yet.";
+  if (state_ != PP_WEBSOCKETREADYSTATE_OPEN_DEV &&
+      state_ != PP_WEBSOCKETREADYSTATE_CLOSING_DEV)
+    return;
+
+  // Pepper binding has no event or callback mechanism for errors.

[dmichael (off chromium), 2011/12/01 17:09:34]

I'm not sure I understand your comment. The idea during the API review was that
you would use error codes from pp_errors.h and invoke the appropriate completion
callback. If you don't have the right error(s) defined there yet, you can define
new ones. You do appear to be calling the receive_callback_ below; what's
missing?

[Takashi Toyoshima, 2011/12/02 05:51:28]

didReceiveMessageError() callback was invoked from WebKit side implementation
when it detect errors on underlaying networks or WebSocket protocol stack itself
every time.
Also other didReceive* callbacks were invoked every time being independent from
calling pepper side APIs.
So didReceive* events could not be binded to some specific callback.

We just queue incoming frame messages and errors in order manner, then
pop a message from top of the queue when the pepper side APIs are called.

I try to revise this comment to be clearer.

+  // Just remember the error, and notice after reading the last message as
+  // returned error code.
+  error_was_received_ = true;
+
+  if (!wait_for_receive_)
+    return;
+
+  // |received_messages| is empty and receiving process is on going. Received
+  // messages after an error is just ignored. So we must abort here.
+  wait_for_receive_ = false;
+  PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_FAILED);

[dmichael (off chromium), 2011/12/01 17:09:34]

Are you guaranteed that you'll still get 'didClose' if we're in the process of
Closing the socket? Or should you also invoke the closing callback if it's
valid?

[Takashi Toyoshima, 2011/12/02 05:51:28]

all didReceiveMessageError() was followed by didClose().
This behavior is described in WebSocket API specification.
And in WebKit side, these did* callbacks is binded to JavaScript API's on*
events.

So, I can guarantee closing callback will be invoked in didClose().

 }
 
 void PPB_WebSocket_Impl::didUpdateBufferedAmount(
     unsigned long buffered_amount) {
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV)
     return;
   buffered_amount_ = buffered_amount;
 }
 
 void PPB_WebSocket_Impl::didStartClosingHandshake() {
-  // TODO(toyoshim): Must implement.
-  DLOG(INFO) << "didStartClosingHandshake is not implemented yet.";
+  state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
 }
 
-void PPB_WebSocket_Impl::didClose(unsigned long buffered_amount,
+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(
       PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), reason_string);
 
-  // TODO(toyoshim): Set close_was_clean_.
+  // Set close_was_clean_.
+  bool was_clean =
+      state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV &&
+      !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;
 
-  // Update buffered_amount_.
-  buffered_amount_ = buffered_amount;
-
   if (state == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
     PP_RunAndClearCompletionCallback(&connect_callback_, PP_OK);
 
   if (state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV)
     PP_RunAndClearCompletionCallback(&close_callback_, PP_OK);
+
+  // Disconnect.
+  if (websocket_.get())
+    websocket_->disconnect();
 }
 
 int32_t PPB_WebSocket_Impl::DoReceive() {
-  // TODO(toyoshim): Check state.
-
   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