PPAPI: Make blocking completion callbacks work.

webkit/plugins/ppapi/ppb_url_loader_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_url_loader_impl.h"
 
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 78 matching lines @@
 PPB_URLLoader_API* PPB_URLLoader_Impl::AsPPB_URLLoader_API() {
   return this;
 }
 
 void PPB_URLLoader_Impl::InstanceWasDeleted() {
   Resource::InstanceWasDeleted();
   loader_.reset();
 }
 
 int32_t PPB_URLLoader_Impl::Open(PP_Resource request_id,
-                                 PP_CompletionCallback callback) {
+                                 scoped_refptr<TrackedCallback> callback) {
   // Main document loads are already open, so don't allow people to open them
   // again.
   if (main_document_loader_)
     return PP_ERROR_INPROGRESS;
 
   EnterResourceNoLock<PPB_URLRequestInfo_API> enter_request(request_id, true);
   if (enter_request.failed()) {
     Log(PP_LOGLEVEL_ERROR,
         "PPB_URLLoader.Open: invalid request resource ID. (Hint to C++ wrapper"
         " users: use the ResourceRequest constructor that takes an instance or"
@@ skipping 55 matching lines @@
   if (!loader_.get())
     return PP_ERROR_FAILED;
 
   loader_->loadAsynchronously(web_request, this);
 
   // Notify completion when we receive a redirect or response headers.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t PPB_URLLoader_Impl::FollowRedirect(PP_CompletionCallback callback) {
+int32_t PPB_URLLoader_Impl::FollowRedirect(
+    scoped_refptr<TrackedCallback> callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
 
   WebURL redirect_url = GURL(response_info_->redirect_url());
 
   SetDefersLoading(false);  // Allow the redirect to continue.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
@@ skipping 22 matching lines @@
   *total_bytes_to_be_received = total_bytes_to_be_received_;
   return PP_TRUE;
 }
 
 PP_Resource PPB_URLLoader_Impl::GetResponseInfo() {
   if (!response_info_)
     return 0;
   return response_info_->GetReference();
 }
 
-int32_t PPB_URLLoader_Impl::ReadResponseBody(void* buffer,
-                                             int32_t bytes_to_read,
-                                             PP_CompletionCallback callback) {
+int32_t PPB_URLLoader_Impl::ReadResponseBody(
+    void* buffer,
+    int32_t bytes_to_read,
+    scoped_refptr<TrackedCallback> callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
   if (!response_info_ || response_info_->body())
     return PP_ERROR_FAILED;
   if (bytes_to_read <= 0 || !buffer)
     return PP_ERROR_BADARGUMENT;
 
   user_buffer_ = static_cast<char*>(buffer);
   user_buffer_size_ = bytes_to_read;
 
   if (!buffer_.empty())
     return FillUserBuffer();
 
   // We may have already reached EOF.
   if (done_status_ != PP_OK_COMPLETIONPENDING) {
     user_buffer_ = NULL;
     user_buffer_size_ = 0;
     return done_status_;
   }
 
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_URLLoader_Impl::FinishStreamingToFile(
-    PP_CompletionCallback callback) {
+    scoped_refptr<TrackedCallback> callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
   if (!response_info_ || !response_info_->body())
     return PP_ERROR_FAILED;
 
   // We may have already reached EOF.
   if (done_status_ != PP_OK_COMPLETIONPENDING)
     return done_status_;
 
@@ skipping 130 matching lines @@
 
 void PPB_URLLoader_Impl::FinishLoading(int32_t done_status) {
   done_status_ = done_status;
   // If the client hasn't called any function that takes a callback since
   // the initial call to Open, or called ReadResponseBody and got a
   // synchronous return, then the callback will be NULL.
   if (TrackedCallback::IsPending(pending_callback_))
     RunCallback(done_status_);
 }
 
-int32_t PPB_URLLoader_Impl::ValidateCallback(PP_CompletionCallback callback) {
-  // We only support non-blocking calls.
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
+int32_t PPB_URLLoader_Impl::ValidateCallback(
+    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(callback);
 
   if (TrackedCallback::IsPending(pending_callback_))
     return PP_ERROR_INPROGRESS;
 
   return PP_OK;
 }
 
-void PPB_URLLoader_Impl::RegisterCallback(PP_CompletionCallback callback) {
-  DCHECK(callback.func);
+void PPB_URLLoader_Impl::RegisterCallback(
+    scoped_refptr<TrackedCallback> callback) {
   DCHECK(!TrackedCallback::IsPending(pending_callback_));
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return;
 
-  pending_callback_ = new TrackedCallback(this, callback);
+  pending_callback_ = callback;
 }
 
 void PPB_URLLoader_Impl::RunCallback(int32_t result) {
   // This may be null only when this is a main document loader.
   if (!pending_callback_.get()) {
     CHECK(main_document_loader_);
     return;
   }
   TrackedCallback::ClearAndRun(&pending_callback_, result);
 }
@@ skipping 47 matching lines @@
 bool PPB_URLLoader_Impl::RecordDownloadProgress() const {
   return request_data_.record_download_progress;
 }
 
 bool PPB_URLLoader_Impl::RecordUploadProgress() const {
   return request_data_.record_upload_progress;
 }
 
 }  // namespace ppapi
 }  // namespace webkit