WebSocket Pepper API: C++ utility class implementation.

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 <set>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 61 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),
+      connect_callback_(PP_BlockUntilComplete()),
+      receive_callback_(PP_BlockUntilComplete()),
       receive_callback_var_(NULL),
       wait_for_receive_(false),
+      close_callback_(PP_BlockUntilComplete()),
       close_code_(0),
       close_was_clean_(PP_FALSE),
       buffered_amount_(0),
       buffered_amount_after_close_(0) {

[Takashi Toyoshima, 2011/12/22 07:56:29]

Replace initializers for callbacks by my ongoing change.

-  connect_callback_.func = NULL;
-  connect_callback_.user_data = NULL;
-  receive_callback_.func = NULL;
-  receive_callback_.user_data = NULL;
-  close_callback_.func = NULL;
-  close_callback_.user_data = NULL;
   empty_string_ = new StringVar("", 0);
 }
 
 PPB_WebSocket_Impl::~PPB_WebSocket_Impl() {
+  // Abort outstanding processings having a callback.
+  if (connect_callback_.func)
+    PP_RunAndClearCompletionCallback(&connect_callback_, PP_ERROR_ABORTED);
+  AbortOutstandingReceive();
+  if (close_callback_.func)
+    PP_RunAndClearCompletionCallback(&close_callback_, PP_ERROR_ABORTED);
+
   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);
   }
@@ skipping 147 matching lines @@
   // 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);
-  }
+  AbortOutstandingReceive();
 
   // 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,
@@ skipping 197 matching lines @@
   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_ERROR_FAILED);
 
-  if (wait_for_receive_) {
-    wait_for_receive_ = false;
-    receive_callback_var_ = NULL;
-    PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_ABORTED);
-  }
+  AbortOutstandingReceive();
 
   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;
 }
 
+void PPB_WebSocket_Impl::AbortOutstandingReceive() {
+  if (!wait_for_receive_)
+    return;
+  wait_for_receive_ = false;
+  receive_callback_var_ = NULL;
+  PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_ABORTED);
+}
+
 }  // namespace ppapi
 }  // namespace webkit