Revert 71334 - Fix Pepper URL Loader callbacks....

webkit/plugins/ppapi/ppb_url_loader_impl.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebKitClient.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLLoader.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLResponse.h"
 #include "webkit/appcache/web_application_cache_host_impl.h"
 #include "webkit/plugins/ppapi/common.h"
-#include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_url_request_info_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_response_info_impl.h"
 
 using appcache::WebApplicationCacheHostImpl;
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
@@ skipping 191 matching lines @@
 const PPB_URLLoaderTrusted* PPB_URLLoader_Impl::GetTrustedInterface() {
   return &ppb_urlloadertrusted;
 }
 
 PPB_URLLoader_Impl* PPB_URLLoader_Impl::AsPPB_URLLoader_Impl() {
   return this;
 }
 
 int32_t PPB_URLLoader_Impl::Open(PPB_URLRequestInfo_Impl* request,
                                  PP_CompletionCallback callback) {
-  int32_t rv = ValidateCallback(callback);
-  if (rv != PP_OK)
-    return rv;
-
   if (loader_.get())
     return PP_ERROR_INPROGRESS;
 
+  // We only support non-blocking calls.
+  if (!callback.func)
+    return PP_ERROR_BADARGUMENT;
+
   WebFrame* frame = GetFrame(instance_);
   if (!frame)
     return PP_ERROR_FAILED;
   WebURLRequest web_request(request->ToWebURLRequest(frame));
 
-  rv = CanRequest(frame, web_request.url());
+  int32_t rv = CanRequest(frame, web_request.url());
   if (rv != PP_OK)
     return rv;
 
   frame->dispatchWillSendRequest(web_request);
 
   // Sets the appcache host id to allow retrieval from the appcache.
   if (WebApplicationCacheHostImpl* appcache_host =
           WebApplicationCacheHostImpl::FromFrame(frame)) {
     appcache_host->willStartSubResourceRequest(web_request);
   }
 
   loader_.reset(WebKit::webKitClient()->createURLLoader());
   if (!loader_.get())
     return PP_ERROR_FAILED;
 
   loader_->loadAsynchronously(web_request, this);
 
   request_info_ = scoped_refptr<PPB_URLRequestInfo_Impl>(request);
+  pending_callback_ = callback;
 
   // Notify completion when we receive a redirect or response headers.
-  RegisterCallback(callback);
   return PP_ERROR_WOULDBLOCK;
 }
 
 int32_t PPB_URLLoader_Impl::FollowRedirect(PP_CompletionCallback callback) {
-  int32_t rv = ValidateCallback(callback);
+  if (pending_callback_.func)
+    return PP_ERROR_INPROGRESS;
+
+  // We only support non-blocking calls.
+  if (!callback.func)
+    return PP_ERROR_BADARGUMENT;
+
+  WebURL redirect_url = GURL(response_info_->redirect_url());
+
+  int32_t rv = CanRequest(GetFrame(instance_), redirect_url);
   if (rv != PP_OK)
     return rv;
 
-  WebURL redirect_url = GURL(response_info_->redirect_url());
-
-  rv = CanRequest(GetFrame(instance_), redirect_url);
-  if (rv != PP_OK)
-    return rv;
-
+  pending_callback_ = callback;
   loader_->setDefersLoading(false);  // Allow the redirect to continue.
-  RegisterCallback(callback);
   return PP_ERROR_WOULDBLOCK;
 }
 
 bool PPB_URLLoader_Impl::GetUploadProgress(int64_t* bytes_sent,
                                            int64_t* total_bytes_to_be_sent) {
   if (!RecordUploadProgress()) {
     *bytes_sent = 0;
     *total_bytes_to_be_sent = 0;
     return false;
   }
@@ skipping 11 matching lines @@
     return false;
   }
   *bytes_received = bytes_received_;
   *total_bytes_to_be_received = total_bytes_to_be_received_;
   return true;
 }
 
 int32_t PPB_URLLoader_Impl::ReadResponseBody(char* buffer,
                                              int32_t bytes_to_read,
                                              PP_CompletionCallback 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;
+  if (pending_callback_.func)
+    return PP_ERROR_INPROGRESS;
+
+  // We only support non-blocking calls.
+  if (!callback.func)
+    return PP_ERROR_BADARGUMENT;
 
   user_buffer_ = buffer;
   user_buffer_size_ = bytes_to_read;
 
   if (!buffer_.empty())
     return FillUserBuffer();
 
   // We may have already reached EOF.
   if (done_status_ != PP_ERROR_WOULDBLOCK) {
     user_buffer_ = NULL;
     user_buffer_size_ = 0;
     return done_status_;
   }
 
-  RegisterCallback(callback);
+  pending_callback_ = callback;
   return PP_ERROR_WOULDBLOCK;
 }
 
 int32_t PPB_URLLoader_Impl::FinishStreamingToFile(
     PP_CompletionCallback callback) {
-  int32_t rv = ValidateCallback(callback);
-  if (rv != PP_OK)
-    return rv;
   if (!response_info_ || !response_info_->body())
     return PP_ERROR_FAILED;
+  if (pending_callback_.func)
+    return PP_ERROR_INPROGRESS;
 
   // We may have already reached EOF.
   if (done_status_ != PP_ERROR_WOULDBLOCK)
     return done_status_;
 
   // Wait for didFinishLoading / didFail.
-  RegisterCallback(callback);
+  pending_callback_ = callback;
   return PP_ERROR_WOULDBLOCK;
 }
 
 void PPB_URLLoader_Impl::Close() {
   if (loader_.get()) {
     loader_->cancel();
   } else if (main_document_loader_) {
     WebFrame* frame = instance_->container()->element().document().frame();
     frame->stopLoading();
   }
-  // TODO(viettrungluu): Check what happens to the callback (probably the
-  // wrong thing). May need to post abort here. crbug.com/69457
 }
 
 void PPB_URLLoader_Impl::GrantUniversalAccess() {
   has_universal_access_ = true;
 }
 
 void PPB_URLLoader_Impl::SetStatusCallback(
     PP_URLLoaderTrusted_StatusCallback cb) {
   status_callback_ = cb;
 }
@@ skipping 44 matching lines @@
 
 void PPB_URLLoader_Impl::didReceiveData(WebURLLoader* loader,
                                         const char* data,
                                         int data_length) {
   bytes_received_ += data_length;
 
   buffer_.insert(buffer_.end(), data, data + data_length);
   if (user_buffer_) {
     RunCallback(FillUserBuffer());
   } else {
-    DCHECK(!pending_callback_.get() || pending_callback_->completed());
+    DCHECK(!pending_callback_.func);
   }
 }
 
 void PPB_URLLoader_Impl::didFinishLoading(WebURLLoader* loader,
                                           double finish_time) {
   done_status_ = PP_OK;
   RunCallback(done_status_);
 }
 
 void PPB_URLLoader_Impl::didFail(WebURLLoader* loader,
@@ skipping 30 matching lines @@
     response_info_ = NULL;
   }
 
   // Free the WebKit request.
   loader_.reset();
 
   // Often, |this| will be deleted at the end of this function when death_grip
   // goes out of scope.
 }
 
-int32_t PPB_URLLoader_Impl::ValidateCallback(PP_CompletionCallback callback) {
-  // We only support non-blocking calls.
-  if (!callback.func)
-    return PP_ERROR_BADARGUMENT;
+void PPB_URLLoader_Impl::RunCallback(int32_t result) {
+  if (!pending_callback_.func)
+    return;
 
-  if (pending_callback_.get() && !pending_callback_->completed())
-    return PP_ERROR_INPROGRESS;
-
-  return PP_OK;
-}
-
-void PPB_URLLoader_Impl::RegisterCallback(PP_CompletionCallback callback) {
-  DCHECK(callback.func);
-  DCHECK(!pending_callback_.get() || pending_callback_->completed());
-
-  PP_Resource resource_id = GetReferenceNoAddRef();
-  CHECK(resource_id);
-  pending_callback_ = new TrackedCompletionCallback(
-      module()->GetCallbackTracker(), resource_id, callback);
-}
-
-void PPB_URLLoader_Impl::RunCallback(int32_t result) {
-  scoped_refptr<TrackedCompletionCallback> callback;
-  callback.swap(pending_callback_);
-  callback->Run(result);  // Will complete abortively if necessary.
+  PP_CompletionCallback callback = {0};
+  std::swap(callback, pending_callback_);
+  PP_RunCompletionCallback(&callback, result);
 }
 
 size_t PPB_URLLoader_Impl::FillUserBuffer() {
   DCHECK(user_buffer_);
   DCHECK(user_buffer_size_);
 
   size_t bytes_to_copy = std::min(buffer_.size(), user_buffer_size_);
   std::copy(buffer_.begin(), buffer_.begin() + bytes_to_copy, user_buffer_);
   buffer_.erase(buffer_.begin(), buffer_.begin() + bytes_to_copy);
 
@@ skipping 48 matching lines @@
   return request_info_ && request_info_->record_download_progress();
 }
 
 bool PPB_URLLoader_Impl::RecordUploadProgress() const {
   return request_info_ && request_info_->record_upload_progress();
 }
 
 }  // namespace ppapi
 }  // namespace webkit