Convert callers to use the new TrackedCallback.

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 15 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSocket.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using ppapi::ArrayBufferVar;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::thunk::PPB_WebSocket_API;
+using ppapi::TrackedCallback;
 using ppapi::VarTracker;
 using WebKit::WebData;
 using WebKit::WebDocument;
 using WebKit::WebString;
 using WebKit::WebSocket;
 using WebKit::WebSocketClient;
 using WebKit::WebURL;
 
 const uint32_t kMaxReasonSizeInBytes = 123;
 const size_t kHybiBaseFramingOverhead = 2;
@@ skipping 29 matching lines @@
 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),
+      empty_string_(new StringVar("", 0)),
       buffered_amount_(0),
       buffered_amount_after_close_(0) {
-  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() {
   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();
@@ skipping 98 matching lines @@
   WebDocument document = plugin_instance->container()->element().document();
   websocket_.reset(WebSocket::create(document, this));
   DCHECK(websocket_.get());
   if (!websocket_.get())
     return PP_ERROR_NOTSUPPORTED;
 
   websocket_->connect(web_url, web_protocols);
   state_ = PP_WEBSOCKETREADYSTATE_CONNECTING_DEV;
 
   // Install callback.
-  connect_callback_ = 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) {
   // Check mandarory interfaces.
   if (!websocket_.get())
     return PP_ERROR_FAILED;
@@ skipping 20 matching lines @@
   // 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;
+  close_callback_ = new TrackedCallback(this, callback);
 
   // Abort ongoing connect.
   if (state_ == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV) {
     state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
-    PP_RunAndClearCompletionCallback(&connect_callback_, PP_ERROR_ABORTED);
+    // 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;
-    PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_ABORTED);
+
+    // Need to do a "Post" to avoid reentering the plugin.
+    receive_callback_->PostAbort();
+    receive_callback_ = NULL;
   }
 
   // Close connection.
   state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
   WebString web_reason = WebString::fromUTF8(reason_string->value());
   websocket_->close(code, web_reason);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
@@ skipping 19 matching lines @@
   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_ = callback;
+  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.
@@ skipping 96 matching lines @@
 
 PP_Var PPB_WebSocket_Impl::GetURL() {
   if (!url_)
     return empty_string_->GetPPVar();
   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);
+  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();
   PP_Var var = StringVar::StringToPPVar(string);
   received_messages_.push(var);
 
   if (!wait_for_receive_)
     return;
 
-  PP_RunAndClearCompletionCallback(&receive_callback_, DoReceive());
+  TrackedCallback::ClearAndRun(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveBinaryData(const WebData& binaryData) {
   // Dispose packets after receiving an error or in invalid state.
   if (error_was_received_ || !InValidStateToReceive(state_))
     return;
 
   // Append received data to queue.
   PP_Var var = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
       binaryData.size());
   scoped_refptr<ArrayBufferVar> arraybuffer = ArrayBufferVar::FromPPVar(var);
   void* data = arraybuffer->Map();
   memcpy(data, binaryData.data(), binaryData.size());
   received_messages_.push(var);
 
   if (!wait_for_receive_)
     return;
 
-  PP_RunAndClearCompletionCallback(&receive_callback_, DoReceive());
+  TrackedCallback::ClearAndRun(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveMessageError() {
   // Ignore error notification in invalid state.
   if (!InValidStateToReceive(state_))
     return;
 
   // 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);
+  TrackedCallback::ClearAndRun(&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;
 }
 
 void PPB_WebSocket_Impl::didStartClosingHandshake() {
@@ skipping 18 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_ERROR_FAILED);
+    TrackedCallback::ClearAndRun(&connect_callback_, PP_ERROR_FAILED);
 
   if (wait_for_receive_) {
     wait_for_receive_ = false;
     receive_callback_var_ = NULL;
-    PP_RunAndClearCompletionCallback(&receive_callback_, PP_ERROR_ABORTED);
+    TrackedCallback::ClearAndAbort(&receive_callback_);
   }
 
   if (state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV)
-    PP_RunAndClearCompletionCallback(&close_callback_, PP_OK);
+    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();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit