PPAPI: Make blocking completion callbacks work.

ppapi/proxy/ppb_file_ref_proxy.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 "ppapi/proxy/ppb_file_ref_proxy.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 20 matching lines @@
 class FileRef : public PPB_FileRef_Shared {
  public:
   explicit FileRef(const PPB_FileRef_CreateInfo& info);
   virtual ~FileRef();
 
   // Resource overrides.
   virtual void LastPluginRefWasDeleted() OVERRIDE;
 
   // PPB_FileRef_API implementation (not provided by PPB_FileRef_Shared).
   virtual PP_Resource GetParent() OVERRIDE;
-  virtual int32_t MakeDirectory(PP_Bool make_ancestors,
-                                PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t MakeDirectory(
+      PP_Bool make_ancestors,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Touch(PP_Time last_access_time,
                         PP_Time last_modified_time,
-                        PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Delete(PP_CompletionCallback callback) OVERRIDE;
+                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t Delete(scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Rename(PP_Resource new_file_ref,
-                         PP_CompletionCallback callback) OVERRIDE;
+                         scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Var GetAbsolutePath() OVERRIDE;
 
   // Executes the pending callback with the given ID. See pending_callbacks_.
   void ExecuteCallback(int callback_id, int32_t result);
 
  private:
   PluginDispatcher* GetDispatcher() const {
     return PluginDispatcher::GetForResource(this);
   }
 
-  // Adds a callback to the list and returns its ID. Returns 0 if the callback
-  // is invalid.
-  int SendCallback(PP_CompletionCallback callback);
+  // Adds a callback to the list and returns its ID.
+  int SendCallback(scoped_refptr<TrackedCallback> callback);
 
   // This class can have any number of out-standing requests with completion
   // callbacks, in contrast to most resources which have one possible pending
   // callback pending (like a Flush callback).
   //
   // To keep track of them, assign integer IDs to the callbacks, which is how
   // the callback will be identified when it's passed to the host and then
-  // back here.
-  int next_callback_id_;
-  typedef std::map<int, scoped_refptr<TrackedCallback> > PendingCallbackMap;
+  // back here. Use unsigned so that overflow is well-defined.
+  unsigned int next_callback_id_;
+  typedef std::map<unsigned int,
+                   scoped_refptr<TrackedCallback> > PendingCallbackMap;
   PendingCallbackMap pending_callbacks_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileRef);
 };
 
 FileRef::FileRef(const PPB_FileRef_CreateInfo& info)
     : PPB_FileRef_Shared(OBJECT_IS_PROXY, info),
-      next_callback_id_(1) {
+      next_callback_id_(0u) {
 }
 
 FileRef::~FileRef() {
   // The callbacks map should have been cleared by LastPluginRefWasDeleted.
   DCHECK(pending_callbacks_.empty());
 }
 
 void FileRef::LastPluginRefWasDeleted() {
   // The callback tracker will abort our callbacks for us.
   pending_callbacks_.clear();
 }
 
 PP_Resource FileRef::GetParent() {
   PPB_FileRef_CreateInfo create_info;
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_GetParent(
       API_ID_PPB_FILE_REF, host_resource(), &create_info));
   return PPB_FileRef_Proxy::DeserializeFileRef(create_info);
 }
 
 int32_t FileRef::MakeDirectory(PP_Bool make_ancestors,
-                               PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+                               scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_MakeDirectory(
-      API_ID_PPB_FILE_REF, host_resource(), make_ancestors, callback_id));
+      API_ID_PPB_FILE_REF, host_resource(), make_ancestors,
+      SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileRef::Touch(PP_Time last_access_time,
                        PP_Time last_modified_time,
-                       PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+                       scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Touch(
-      API_ID_PPB_FILE_REF, host_resource(),
-      last_access_time, last_modified_time, callback_id));
+      API_ID_PPB_FILE_REF, host_resource(), last_access_time,
+      last_modified_time, SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t FileRef::Delete(PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+int32_t FileRef::Delete(scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Delete(
-      API_ID_PPB_FILE_REF, host_resource(), callback_id));
+      API_ID_PPB_FILE_REF, host_resource(), SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileRef::Rename(PP_Resource new_file_ref,
-                        PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+                        scoped_refptr<TrackedCallback> callback) {
   Resource* new_file_ref_object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(new_file_ref);
   if (!new_file_ref_object ||
       new_file_ref_object->host_resource().instance() != pp_instance())
     return PP_ERROR_BADRESOURCE;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Rename(
       API_ID_PPB_FILE_REF, host_resource(),
-      new_file_ref_object->host_resource(), callback_id));
+      new_file_ref_object->host_resource(), SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Var FileRef::GetAbsolutePath() {
   ReceiveSerializedVarReturnValue result;
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_GetAbsolutePath(
       API_ID_PPB_FILE_REF, host_resource(), &result));
   return result.Return(GetDispatcher());
 }
 
 void FileRef::ExecuteCallback(int callback_id, int32_t result) {
   PendingCallbackMap::iterator found = pending_callbacks_.find(callback_id);
   if (found == pending_callbacks_.end()) {
     // This will happen when the plugin deletes its resource with a pending
     // callback. The callback will be locally issued with an ABORTED call while
     // the operation may still be pending in the renderer.
     return;
   }
 
   // Executing the callback may mutate the callback list.
   scoped_refptr<TrackedCallback> callback = found->second;
   pending_callbacks_.erase(found);
   callback->Run(result);
 }
 
-int FileRef::SendCallback(PP_CompletionCallback callback) {
-  if (!callback.func)
-    return 0;
+int FileRef::SendCallback(scoped_refptr<TrackedCallback> callback) {
+  // In extreme cases the IDs may wrap around, so avoid duplicates.
+  while (pending_callbacks_.count(next_callback_id_))
+    ++next_callback_id_;
 
-  // In extreme cases the IDs may wrap around, so avoid duplicates.
-  while (pending_callbacks_.find(next_callback_id_) != pending_callbacks_.end())
-    next_callback_id_++;
-
-  pending_callbacks_[next_callback_id_] = new TrackedCallback(this, callback);
+  pending_callbacks_[next_callback_id_] = callback;
   return next_callback_id_++;
 }
 
 namespace {
 
 InterfaceProxy* CreateFileRefProxy(Dispatcher* dispatcher) {
   return new PPB_FileRef_Proxy(dispatcher);
 }
 
 }  // namespace
@@ skipping 144 matching lines @@
     int32_t result,
     const HostResource& host_resource,
     int callback_id) {
   // Execute OnMsgCallbackComplete in the plugin process.
   Send(new PpapiMsg_PPBFileRef_CallbackComplete(
       API_ID_PPB_FILE_REF, host_resource, callback_id, result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi