PPAPI: Force async callback invocation option.

webkit/plugins/ppapi/ppb_url_loader_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_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_core.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.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/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
@@ skipping 20 matching lines @@
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
+int32_t CompletionResult(PP_CompletionCallback callback, int32_t result) {
+  if (callback.func == NULL ||
+      (callback.flags & PP_COMPLETIONCALLBACK_FLAG_NOFORCEASYNC) != 0)
+    return result;
+
+  PluginModule::GetCore()->CallOnMainThread(0, callback, result);
+  return PP_OK_COMPLETIONPENDING;
+}
+
 PP_Resource Create(PP_Instance instance_id) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return 0;
 
   PPB_URLLoader_Impl* loader = new PPB_URLLoader_Impl(instance, false);
   return loader->GetReference();
 }
 
 PP_Bool IsURLLoader(PP_Resource resource) {
   return BoolToPPBool(!!Resource::GetAs<PPB_URLLoader_Impl>(resource));
 }
 
 int32_t Open(PP_Resource loader_id,
              PP_Resource request_id,
              PP_CompletionCallback callback) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
-    return PP_ERROR_BADRESOURCE;
+    return CompletionResult(callback, PP_ERROR_BADRESOURCE);
 
   scoped_refptr<PPB_URLRequestInfo_Impl> request(
       Resource::GetAs<PPB_URLRequestInfo_Impl>(request_id));
   if (!request)
-    return PP_ERROR_BADRESOURCE;
+    return CompletionResult(callback, PP_ERROR_BADRESOURCE);
 
   return loader->Open(request, callback);
 }
 
 int32_t FollowRedirect(PP_Resource loader_id,
                        PP_CompletionCallback callback) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
     return PP_ERROR_BADRESOURCE;
@@ skipping 38 matching lines @@
   return response_info->GetReference();
 }
 
 int32_t ReadResponseBody(PP_Resource loader_id,
                          void* buffer,
                          int32_t bytes_to_read,
                          PP_CompletionCallback callback) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
     return PP_ERROR_BADRESOURCE;

[darin (slow to review), 2011/04/25 18:31:06]

what about this case?

[polina, 2011/04/25 19:44:44]

I could not get ppapi_tests for url_loader get passed an Open failure for bad
request, so I left this code as is until I could test it. I must have something
wrong with my test set-up.

 
   return loader->ReadResponseBody(buffer, bytes_to_read, callback);
 }
 
 int32_t FinishStreamingToFile(PP_Resource loader_id,
                               PP_CompletionCallback callback) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
     return PP_ERROR_BADRESOURCE;

[darin (slow to review), 2011/04/25 18:31:06]

what about this case?  and the others like this...

[polina, 2011/04/25 19:44:44]

same reply as above.

 
   return loader->FinishStreamingToFile(callback);
 }
 
 void Close(PP_Resource loader_id) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
     return;
 
@@ skipping 81 matching lines @@
     // Free the WebKit request when the instance has been destroyed to avoid
     // using bandwidth just in case this object lives longer than the instance.
     loader_.reset();
   }
 }
 
 int32_t PPB_URLLoader_Impl::Open(PPB_URLRequestInfo_Impl* request,
                                  PP_CompletionCallback callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
-    return rv;
+    return CompletionResult(callback, rv);

[darin (slow to review), 2011/04/25 18:31:06]

I think it would be better to put the callback fixup code into the entry points
(that ppb_urlloader points to) so that the implementation classes will not need
to change.

(For "Open" you have some of the checks in PPB_URLLoader_Impl::Open and others
in Open.)

Eventually, we might be able to auto-generate the entry point stubs, and this
callback fixup could easily be auto-generated.

[polina, 2011/04/25 19:44:44]

Do you mean put this in outer Open where it has:
 return loader->Open(request, callback);?

 
   if (request->RequiresUniversalAccess() && !has_universal_access_)
-    return PP_ERROR_BADARGUMENT;
+    // Why is this not PP_ERROR_NOACCESS?
+    return CompletionResult(callback, PP_ERROR_BADARGUMENT);
 
   if (loader_.get())
-    return PP_ERROR_INPROGRESS;
+    return CompletionResult(callback, PP_ERROR_INPROGRESS);
 
   WebFrame* frame = GetFrame(instance());
   if (!frame)
-    return PP_ERROR_FAILED;
-  WebURLRequest web_request(request->ToWebURLRequest(frame));
+    return CompletionResult(callback, PP_ERROR_FAILED);
 
   WebURLLoaderOptions options;
   if (has_universal_access_) {
     // Universal access allows cross-origin requests and sends credentials.
     options.crossOriginRequestPolicy =
         WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
     options.allowCredentials = true;
   } else if (request->allow_cross_origin_requests()) {
     // Otherwise, allow cross-origin requests with access control.
     options.crossOriginRequestPolicy =
         WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
     options.allowCredentials = request->allow_credentials();
   }
 
   loader_.reset(frame->createAssociatedURLLoader(options));
   if (!loader_.get())
-    return PP_ERROR_FAILED;
+    return CompletionResult(callback, PP_ERROR_FAILED);
 
+  WebURLRequest web_request(request->ToWebURLRequest(frame));
   loader_->loadAsynchronously(web_request, this);
   // Check for immediate failure; The AssociatedURLLoader will call our
   // didFail method synchronously for certain kinds of access violations
   // so we must return an error to the caller.
   // TODO(bbudge) Modify the underlying AssociatedURLLoader to only call
   // back asynchronously.
   if (done_status_ == PP_ERROR_FAILED)
-    return PP_ERROR_NOACCESS;
+    return CompletionResult(callback, PP_ERROR_NOACCESS);
 
   request_info_ = scoped_refptr<PPB_URLRequestInfo_Impl>(request);
 
   // 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 rv = ValidateCallback(callback);
   if (rv != PP_OK)
-    return rv;
+    return CompletionResult(callback, rv);
 
   WebURL redirect_url = GURL(response_info_->redirect_url());
 
   loader_->setDefersLoading(false);  // Allow the redirect to continue.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 bool PPB_URLLoader_Impl::GetUploadProgress(int64_t* bytes_sent,
                                            int64_t* total_bytes_to_be_sent) {
@@ skipping 18 matching lines @@
   *bytes_received = bytes_received_;
   *total_bytes_to_be_received = total_bytes_to_be_received_;
   return true;
 }
 
 int32_t PPB_URLLoader_Impl::ReadResponseBody(void* buffer,
                                              int32_t bytes_to_read,
                                              PP_CompletionCallback callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
-    return rv;
+    return CompletionResult(callback, rv);
   if (!response_info_ || response_info_->body())
-    return PP_ERROR_FAILED;
+    return CompletionResult(callback, PP_ERROR_FAILED);
   if (bytes_to_read <= 0 || !buffer)
-    return PP_ERROR_BADARGUMENT;
+    return CompletionResult(callback, PP_ERROR_BADARGUMENT);
 
   user_buffer_ = static_cast<char*>(buffer);
   user_buffer_size_ = bytes_to_read;
 
   if (!buffer_.empty())
-    return FillUserBuffer();
+    return CompletionResult(callback, FillUserBuffer());
 
   // We may have already reached EOF.
   if (done_status_ != PP_OK_COMPLETIONPENDING) {
     user_buffer_ = NULL;
     user_buffer_size_ = 0;
-    return done_status_;
+    return CompletionResult(callback, done_status_);
   }
 
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_URLLoader_Impl::FinishStreamingToFile(
     PP_CompletionCallback callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
-    return rv;
+    return CompletionResult(callback, rv);
   if (!response_info_ || !response_info_->body())
-    return PP_ERROR_FAILED;
+    return CompletionResult(callback, PP_ERROR_FAILED);
 
   // We may have already reached EOF.
   if (done_status_ != PP_OK_COMPLETIONPENDING)
-    return done_status_;
+    return CompletionResult(callback, done_status_);
 
   // Wait for didFinishLoading / didFail.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_URLLoader_Impl::Close() {
   if (loader_.get()) {
     loader_->cancel();
   } else if (main_document_loader_) {
@@ skipping 161 matching lines @@
 bool PPB_URLLoader_Impl::RecordDownloadProgress() const {
   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