Add RequestOSFileHandle as a private PPAPI

ppapi/proxy/file_io_resource.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/file_io_resource.h"
 
 #include "base/bind.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 167 matching lines @@
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void FileIOResource::Close() {
   Post(RENDERER, PpapiHostMsg_FileIO_Close());
 }
 
 int32_t FileIOResource::GetOSFileDescriptor() {
-  int32_t file_descriptor;
-  // Only available when running in process.
-  SyncCall<PpapiPluginMsg_FileIO_GetOSFileDescriptorReply>(
-      RENDERER, PpapiHostMsg_FileIO_GetOSFileDescriptor(), &file_descriptor);
-  return file_descriptor;
+  IPC::Message reply;
+  ResourceMessageReplyParams reply_params;
+  int32_t error = GenericSyncCall(RENDERER,
+      PpapiHostMsg_FileIO_GetOSFileDescriptor(), &reply, &reply_params);
+  if (error != PP_OK)
+    return error;
+
+  IPC::PlatformFileForTransit transit_file;
+  if (!reply_params.TakeFileHandleAtIndex(0, &transit_file))
+    return PP_ERROR_FAILED;
+  base::PlatformFile file =
+    IPC::PlatformFileForTransitToPlatformFile(transit_file);
+#if defined(OS_POSIX)
+    return file;
+#elif defined(OS_WIN)
+    return reinterpret_cast<uintptr_t>(file);
+#else
+    return -1;  // Platform not supported.
+#endif
 }
 
 int32_t FileIOResource::WillWrite(int64_t offset,
                                   int32_t bytes_to_write,
                                   scoped_refptr<TrackedCallback> callback) {
   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
       PpapiHostMsg_FileIO_WillWrite(offset, bytes_to_write),
       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
                  callback));
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
@@ skipping 14 matching lines @@
                                       int32_t bytes_to_read,
                                       const PP_ArrayOutput& array_output,
                                       scoped_refptr<TrackedCallback> callback) {
   Call<PpapiPluginMsg_FileIO_ReadReply>(RENDERER,
       PpapiHostMsg_FileIO_Read(offset, bytes_to_read),
       base::Bind(&FileIOResource::OnPluginMsgReadComplete, this,
                  callback, array_output));
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t FileIOResource::GetOSFileHandle(

[dmichael (off chromium), 2013/03/27 19:40:53]

Maybe RequestOSFileHandle? I think synchronous when I read Get.

[hamaji, 2013/03/28 00:17:29]

Done.

+    PP_FileHandle* handle,
+    scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_EXCLUSIVE, true);
+  if (rv != PP_OK)
+    return rv;
+
+  Call<PpapiPluginMsg_FileIO_GetOSFileDescriptorReply>(RENDERER,
+      PpapiHostMsg_FileIO_GetOSFileDescriptor(),
+      base::Bind(&FileIOResource::OnPluginMsgGetOSFileHandleComplete, this,
+                 callback, handle));
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
 void FileIOResource::OnPluginMsgGeneralComplete(
     scoped_refptr<TrackedCallback> callback,
     const ResourceMessageReplyParams& params) {
   DCHECK(state_manager_.get_pending_operation() ==
          FileIOStateManager::OPERATION_EXCLUSIVE ||
          state_manager_.get_pending_operation() ==
          FileIOStateManager::OPERATION_WRITE);
   // End the operation now. The callback may perform another file operation.
   state_manager_.SetOperationFinished();
   callback->Run(params.result());
@@ skipping 42 matching lines @@
   if (output.is_valid())
     output.StoreArray(data.data(), std::max(0, result));
   else
     result = PP_ERROR_FAILED;
 
   // End the operation now. The callback may perform another file operation.
   state_manager_.SetOperationFinished();
   callback->Run(result);
 }
 
+void FileIOResource::OnPluginMsgGetOSFileHandleComplete(
+    scoped_refptr<TrackedCallback> callback,
+    PP_FileHandle* output_handle,
+    const ResourceMessageReplyParams& params) {
+  DCHECK(state_manager_.get_pending_operation() ==
+         FileIOStateManager::OPERATION_EXCLUSIVE);

[yzshen1, 2013/03/27 20:47:58]

Please check whether |callback| is pending. It is possible that |callback| is
aborted. (For example, the last plugin ref has been released.) If yes, nothing
needs to be done except changing state_manager_. Especially, |output_handle|
should not be touched. The plugin has probably deleted the memory.

[hamaji, 2013/03/28 00:17:29]

Done. I'm not 100% sure if I understood your comment. Hope this change is what
you said.

[yzshen1, 2013/03/28 20:59:49]

Yes.

What I was talking about is that the plugin may have already got its callback
run with a PP_ERRROR_ABORTED return value. In that case, it won't get another
notification even if you do callback->Run(). Moreover, because the callback has
been run, the plugin may have decided to delete the memory allocated for
|output_handle| because from its point of view the call has completed.

On 2013/03/28 00:17:29, hamaji wrote:

[hamaji, 2013/03/28 21:37:15]

Thanks for your explanation!

On 2013/03/28 20:59:49, yzshen1 wrote:

+
+  int32_t result = params.result();
+  IPC::PlatformFileForTransit transit_file;
+  if (!params.TakeFileHandleAtIndex(0, &transit_file))
+    result = PP_ERROR_FAILED;
+  *output_handle = IPC::PlatformFileForTransitToPlatformFile(transit_file);
+
+  // End the operation now. The callback may perform another file operation.
+  state_manager_.SetOperationFinished();
+  callback->Run(result);
+}
+
 }  // namespace proxy
 }  // namespace ppapi
-