PPAPI: Make blocking completion callbacks work.

webkit/plugins/ppapi/ppb_websocket_impl.cc

 // Copyright (c) 2012 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 11 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebArrayBuffer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSocket.h"
 #include "webkit/plugins/ppapi/host_array_buffer_var.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::ApiCallbackType;
 using ppapi::ArrayBufferVar;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::thunk::PPB_WebSocket_API;
 using ppapi::TrackedCallback;
 using ppapi::Var;
 using ppapi::VarTracker;
 using WebKit::WebArrayBuffer;
 using WebKit::WebDocument;
 using WebKit::WebString;
@@ skipping 58 matching lines @@
   return ws->GetReference();
 }
 
 PPB_WebSocket_API* PPB_WebSocket_Impl::AsPPB_WebSocket_API() {
   return this;
 }
 
 int32_t PPB_WebSocket_Impl::Connect(PP_Var url,
                                     const PP_Var protocols[],
                                     uint32_t protocol_count,
-                                    PP_CompletionCallback callback) {
+                                    ApiCallbackType callback) {
   // Check mandatory interfaces.
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   DCHECK(plugin_instance);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
 
   // Connect() can be called at most once.
   if (websocket_.get())
     return PP_ERROR_INPROGRESS;
   if (state_ != PP_WEBSOCKETREADYSTATE_INVALID)
@@ skipping 53 matching lines @@
           character == '{' || character == '}')
         return PP_ERROR_BADARGUMENT;
     }
     // Join protocols with the comma separator.
     if (i != 0)
       protocol_string.append(",");
     protocol_string.append(protocol->value());
   }
   WebString web_protocols = WebString::fromUTF8(protocol_string);
 
-  // Validate |callback| (Doesn't support blocking callback)
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
   // Create WebKit::WebSocket object and connect.
   WebDocument document = plugin_instance->container()->element().document();
   websocket_.reset(WebSocket::create(document, this));
   DCHECK(websocket_.get());
   if (!websocket_.get())
     return PP_ERROR_NOTSUPPORTED;
 
   // Set receiving binary object type.
   websocket_->setBinaryType(WebSocket::BinaryTypeArrayBuffer);
 
   websocket_->connect(web_url, web_protocols);
   state_ = PP_WEBSOCKETREADYSTATE_CONNECTING;
 
   // Install callback.
-  connect_callback_ = new TrackedCallback(this, callback);
+  connect_callback_ = callback;
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_WebSocket_Impl::Close(uint16_t code,
                                   PP_Var reason,
-                                  PP_CompletionCallback callback) {
+                                  ApiCallbackType callback) {
   // Check mandarory interfaces.
   if (!websocket_.get())
     return PP_ERROR_FAILED;
 
   // Validate |code|. Need to cast |CloseEventCodeNotSpecified| which is -1 to
   // uint16_t for the comparison to work.
   if (code != static_cast<uint16_t>(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 ||
       state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
     return PP_ERROR_INPROGRESS;
 
-  // Validate |callback| (Doesn't support blocking callback)
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
   // Install |callback|.
-  close_callback_ = new TrackedCallback(this, callback);
+  close_callback_ = callback;
 
   // Abort ongoing connect.
   if (state_ == PP_WEBSOCKETREADYSTATE_CONNECTING) {
     state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
     // 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;
@@ skipping 11 matching lines @@
 
   // Close connection.
   state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
   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) {
+                                           ApiCallbackType callback) {
   // Check state.
   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
     return PP_ERROR_BADARGUMENT;
 
   // Just return received message if any received message is queued.
   if (!received_messages_.empty()) {
     receive_callback_var_ = message;
     return DoReceive();
   }
 
   // Check state again. In CLOSED state, no more messages will be received.
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
     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|.
   wait_for_receive_ = true;
   receive_callback_var_ = message;
-  receive_callback_ = new TrackedCallback(this, callback);
+  receive_callback_ = 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 210 matching lines @@
 
   *receive_callback_var_ = received_messages_.front()->GetPPVar();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit