PPAPI: Force async callback invocation option.

ppapi/proxy/ppb_url_loader_proxy.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 "ppapi/proxy/ppb_url_loader_proxy.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_url_response_info_proxy.h"
+#include "ppapi/thunk/common.h"
 
 #if defined(OS_LINUX)
 #include <sys/shm.h>
 #endif
 
 namespace pp {
 namespace proxy {
 
 class URLLoader : public PluginResource {
  public:
@@ skipping 136 matching lines @@
   URLLoader* object = PluginResource::GetAs<URLLoader>(resource);
   return BoolToPPBool(!!object);
 }
 
 int32_t Open(PP_Resource loader_id,
              PP_Resource request_id,
              PP_CompletionCallback callback) {
   URLLoader* loader_object;
   PluginDispatcher* dispatcher;
   if (!RoutingDataFromURLLoader(loader_id, &loader_object, &dispatcher))
-    return PP_ERROR_BADRESOURCE;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADRESOURCE);
   PluginResource* request_object =
       PluginResourceTracker::GetInstance()->GetResourceObject(request_id);
   if (!request_object)
-    return PP_ERROR_BADRESOURCE;
+    return  ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Open(
       INTERFACE_ID_PPB_URL_LOADER, loader_object->host_resource(),
       request_object->host_resource(),
       dispatcher->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FollowRedirect(PP_Resource loader_id,
                        PP_CompletionCallback callback) {
   URLLoader* loader_object;
   PluginDispatcher* dispatcher;
   if (!RoutingDataFromURLLoader(loader_id, &loader_object, &dispatcher))
-    return PP_ERROR_BADRESOURCE;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_FollowRedirect(
       INTERFACE_ID_PPB_URL_LOADER, loader_object->host_resource(),
       dispatcher->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool GetUploadProgress(PP_Resource loader_id,
                           int64_t* bytes_sent,
                           int64_t* total_bytes_to_be_sent) {
@@ skipping 29 matching lines @@
   return object->GetResponseInfo();
 }
 
 int32_t ReadResponseBody(PP_Resource loader_id,
                          void* buffer,
                          int32_t bytes_to_read,
                          PP_CompletionCallback callback) {
   URLLoader* object;
   PluginDispatcher* dispatcher;
   if (!RoutingDataFromURLLoader(loader_id, &object, &dispatcher))
-    return PP_ERROR_BADRESOURCE;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
   if (!buffer || bytes_to_read <= 0)

[piman, 2011/06/07 17:32:14]

add braces around the next 2 lines

[polina, 2011/06/09 23:53:51]

Done.

-    return PP_ERROR_BADARGUMENT;  // Must specify an output buffer.
+    // Must specify an output buffer.
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADARGUMENT);
   if (object->current_read_callback_.func)

[piman, 2011/06/07 17:32:14]

add braces around the next 2 lines

[polina, 2011/06/09 23:53:51]

Done.

-    return PP_ERROR_INPROGRESS;  // Can only have one request pending.
+    // Can only have one request pending.
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_INPROGRESS);
 
   // Currently we don't support sync calls to read. We'll need to revisit
   // how this works when we allow blocking calls (from background threads).
   if (!callback.func)
-    return PP_ERROR_BADARGUMENT;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADARGUMENT);
 
   if (static_cast<size_t>(bytes_to_read) <= object->buffer_.size()) {
     // Special case: we've buffered enough data to be able to synchronously
     // return data to the caller. Do so without making IPCs.
     object->PopBuffer(buffer, bytes_to_read);
-    return bytes_to_read;
+    return ppapi::thunk::MayForceCallback(callback, bytes_to_read);
   }
 
   object->current_read_callback_ = callback;
   object->current_read_buffer_ = buffer;
   object->current_read_buffer_size_ = bytes_to_read;
 
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_ReadResponseBody(
       INTERFACE_ID_PPB_URL_LOADER,
       object->host_resource(), bytes_to_read));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FinishStreamingToFile(PP_Resource loader_id,
                               PP_CompletionCallback callback) {
   URLLoader* loader_object;
   PluginDispatcher* dispatcher;
   if (!RoutingDataFromURLLoader(loader_id, &loader_object, &dispatcher))
-    return PP_ERROR_BADRESOURCE;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_FinishStreamingToFile(
       INTERFACE_ID_PPB_URL_LOADER, loader_object->host_resource(),
       dispatcher->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void Close(PP_Resource loader_id) {
   URLLoader* loader_object;
   PluginDispatcher* dispatcher;
@@ skipping 354 matching lines @@
   return handled;
 }
 
 void PPB_URLLoaderTrusted_Proxy::OnMsgGrantUniversalAccess(
     const HostResource& loader) {
   ppb_url_loader_trusted_target()->GrantUniversalAccess(loader.host_resource());
 }
 
 }  // namespace proxy
 }  // namespace pp