Add Query() support to FileRef

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 "base/debug/stack_trace.h"

[dmichael (off chromium), 2013/03/18 23:16:16]

^^ leftover from debugging

 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_file_ref.h"
 #include "ppapi/c/private/ppb_file_ref_private.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppb_file_ref_shared.h"
@@ skipping 20 matching lines @@
   virtual PP_Resource GetParent() 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,
                         scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Delete(scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Rename(PP_Resource new_file_ref,
                          scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t Query(PP_FileInfo *info,
+                        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);
+  void SetFileInfo(int callback_id, const PP_FileInfo &info);
 
  private:
   PluginDispatcher* GetDispatcher() const {
     return PluginDispatcher::GetForResource(this);
   }
 
   // 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. 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_;
 
+  // Used to keep pointers to PP_FileInfo instances that are written before
+  // callbacks are invoked. The id of a pending file info will match that of
+  // the corresponding callback.
+  typedef std::map<unsigned int, PP_FileInfo*> PendingFileInfoMap;

[dmichael (off chromium), 2013/03/18 23:16:16]

It looks like you're using |int| instead of |unsigned int| for the callback id
elsewhere.

[teravest, 2013/03/21 16:45:04]

This is a little gross. PpapiMsg_PPBFileRef_CallbackComplete uses an int for the
callback_id, but we're obviously using unsigned int internally here.

Do you want me to clean this all up as part of this patch?

[dmichael (off chromium), 2013/03/21 22:11:29]

Hmm, I guess you aren't making it worse, so you could do it separately if you
want. But it should probably be changed. I'm guessing you could make them it
uint32_t everywhere and be more consistent with what other messages do.

+  PendingFileInfoMap pending_file_infos_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileRef);
 };
 
 FileRef::FileRef(const PPB_FileRef_CreateInfo& info)
     : PPB_FileRef_Shared(OBJECT_IS_PROXY, info),
       next_callback_id_(0u) {
 }
 
 FileRef::~FileRef() {
   // The callbacks map should have been cleared by LastPluginRefWasDeleted.
@@ skipping 42 matching lines @@
   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(), SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t FileRef::Query(PP_FileInfo* info,
+                       scoped_refptr<TrackedCallback> callback) {
+  // Store the pending file info id.
+  int id = SendCallback(callback);
+  pending_file_infos_[id] = info;
+  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Query(
+      API_ID_PPB_FILE_REF, host_resource(), id));
+  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);
 }
 
+void FileRef::SetFileInfo(int callback_id, const PP_FileInfo &info) {
+  PendingFileInfoMap::iterator found = pending_file_infos_.find(callback_id);
+  if (found == pending_file_infos_.end())
+    return;
+  PP_FileInfo *target_info = found->second;

[dmichael (off chromium), 2013/03/18 23:16:16]

nit: '*' should be with PP_FileInfo

[teravest, 2013/03/21 16:45:04]

Done.

+  *target_info = info;
+  pending_file_infos_.erase(found);
+}
+
 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_;
 
   pending_callbacks_[next_callback_id_] = callback;
   return next_callback_id_++;
 }
 
 PPB_FileRef_Proxy::PPB_FileRef_Proxy(Dispatcher* dispatcher)
@@ skipping 24 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_FileRef_Proxy, msg)
 #if !defined(OS_NACL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Create, OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_GetParent, OnMsgGetParent)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_MakeDirectory,
                         OnMsgMakeDirectory)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Touch, OnMsgTouch)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Delete, OnMsgDelete)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Rename, OnMsgRename)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Query, OnMsgQuery)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_GetAbsolutePath,
                         OnMsgGetAbsolutePath)
 #endif  // !defined(OS_NACL)
 
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileRef_CallbackComplete,
                         OnMsgCallbackComplete)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileRef_QueryCallbackComplete,
+                        OnMsgQueryCallbackComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 // static
 void PPB_FileRef_Proxy::SerializeFileRef(PP_Resource file_ref,
                                          PPB_FileRef_CreateInfo* result) {
   EnterResourceNoLock<PPB_FileRef_API> enter(file_ref, false);
   if (enter.succeeded())
@@ skipping 68 matching lines @@
                                     int callback_id) {
   EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
       file_ref, callback_factory_,
       &PPB_FileRef_Proxy::OnCallbackCompleteInHost, file_ref, callback_id);
   if (enter.succeeded()) {
     enter.SetResult(enter.object()->Rename(new_file_ref.host_resource(),
                                            enter.callback()));
   }
 }
 
+void PPB_FileRef_Proxy::OnMsgQuery(const HostResource& file_ref,
+                                   int callback_id) {
+  PP_FileInfo info;
+  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
+      file_ref, callback_factory_,
+      &PPB_FileRef_Proxy::OnQueryCallbackCompleteInHost, file_ref, &info,
+      callback_id);
+  if (enter.succeeded())
+    enter.SetResult(enter.object()->Query(&info, enter.callback()));
+}
+
 void PPB_FileRef_Proxy::OnMsgGetAbsolutePath(const HostResource& host_resource,
                                              SerializedVarReturnValue result) {
   EnterHostFromHostResource<PPB_FileRef_API> enter(host_resource);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.object()->GetAbsolutePath());
 }
 #endif  // !defined(OS_NACL)
 
 void PPB_FileRef_Proxy::OnMsgCallbackComplete(
     const HostResource& host_resource,
     int callback_id,
     int32_t result) {
   // Forward the callback info to the plugin resource.
   EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource);
   if (enter.succeeded())
     static_cast<FileRef*>(enter.object())->ExecuteCallback(callback_id, result);
 }
 
+void PPB_FileRef_Proxy::OnMsgQueryCallbackComplete(
+    const HostResource& host_resource,
+    PP_FileInfo info,
+    int callback_id,
+    int32_t result) {
+  EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource);
+  if (enter.succeeded()) {
+    // Set the FileInfo output parameter.
+    static_cast<FileRef*>(enter.object())->SetFileInfo(callback_id, info);
+    static_cast<FileRef*>(enter.object())->ExecuteCallback(callback_id, result);
+  }
+}
+
 #if !defined(OS_NACL)
 void PPB_FileRef_Proxy::OnCallbackCompleteInHost(
     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));
 }
+
+void PPB_FileRef_Proxy::OnQueryCallbackCompleteInHost(
+    int32_t result,
+    const HostResource& host_resource,
+    PP_FileInfo* info,
+    int callback_id) {
+  if (result == PP_OK) {
+    Send(new PpapiMsg_PPBFileRef_QueryCallbackComplete(
+        API_ID_PPB_FILE_REF, host_resource, *info, callback_id, result));
+  } else {
+    PP_FileInfo tmp_info;
+    memset(&tmp_info, 0, sizeof(tmp_info));

[dmichael (off chromium), 2013/03/18 23:16:16]

Shouldn't this just be done in PPB_FileRef_Impl? It seems like you shouldn't
need to special case this here

[teravest, 2013/03/21 16:45:04]

I'm special casing it in the proxy because we can't send uninitialized data over
IPC. I don't think we need to zero-out the output parameter in every case.

[dmichael (off chromium), 2013/03/21 22:11:29]

What if you just implement the host side so that it's guaranteed not to modify
the PP_FileInfo (it's probably that way anyway). I think that's consistent with
what we do elsewhere. In that case, you can initialize PP_FileInfo to 0 before
the call unconditionally, and get rid of the if.

WDYT?

+    Send(new PpapiMsg_PPBFileRef_QueryCallbackComplete(
+        API_ID_PPB_FILE_REF, host_resource, tmp_info, callback_id, result));
+  }
+}
 #endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi