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 39 matching lines @@
 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 MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
   scoped_refptr<PPB_URLRequestInfo_Impl> request(
       Resource::GetAs<PPB_URLRequestInfo_Impl>(request_id));
   if (!request)
-    return PP_ERROR_BADRESOURCE;
+    return MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
-  return loader->Open(request, callback);
+  int32_t result = loader->Open(request, callback);
+  return MayForceCallback(callback, result);
 }
 
 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;
+    return MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
-  return loader->FollowRedirect(callback);
+  int32_t result = loader->FollowRedirect(callback);
+  return MayForceCallback(callback, result);
 }
 
 PP_Bool GetUploadProgress(PP_Resource loader_id,
                           int64_t* bytes_sent,
                           int64_t* total_bytes_to_be_sent) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
     return PP_FALSE;
 
@@ skipping 26 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;
+    return MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
-  return loader->ReadResponseBody(buffer, bytes_to_read, callback);
+  int32_t result = loader->ReadResponseBody(buffer, bytes_to_read, callback);
+  return MayForceCallback(callback, result);
 }
 
 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;
+    return MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
-  return loader->FinishStreamingToFile(callback);
+  int32_t result = loader->FinishStreamingToFile(callback);
+  return MayForceCallback(callback, result);
 }
 
 void Close(PP_Resource loader_id) {
   scoped_refptr<PPB_URLLoader_Impl> loader(
       Resource::GetAs<PPB_URLLoader_Impl>(loader_id));
   if (!loader)
     return;
 
   loader->Close();
 }
@@ skipping 84 matching lines @@
   }
 }
 
 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 (request->RequiresUniversalAccess() && !has_universal_access_)
-    return PP_ERROR_BADARGUMENT;
+    return PP_ERROR_NOACCESS;
 
   if (loader_.get())
     return PP_ERROR_INPROGRESS;
 
   WebFrame* frame = GetFrame(instance());
   if (!frame)
     return PP_ERROR_FAILED;
-  WebURLRequest web_request(request->ToWebURLRequest(frame));
 
   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();
   }
 
   is_asynchronous_load_suspended_ = false;
   loader_.reset(frame->createAssociatedURLLoader(options));
   if (!loader_.get())
     return 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;
 
   request_info_ = scoped_refptr<PPB_URLRequestInfo_Impl>(request);
@@ skipping 285 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