Refactor FileIO to the new design

ppapi/proxy/file_io_resource.cc

Index: ppapi/proxy/file_io_resource.cc
diff --git a/ppapi/proxy/file_io_resource.cc b/ppapi/proxy/file_io_resource.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b5fcef7a9134b5e91969a9300e82864bbfe9d227
--- /dev/null
+++ b/ppapi/proxy/file_io_resource.cc
@@ -0,0 +1,286 @@
+// 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"
+#include "ppapi/shared_impl/array_writer.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/resource_tracker.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_file_ref_api.h"
+
+using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_FileIO_API;
+using ppapi::thunk::PPB_FileRef_API;
+
+namespace {
+
+// An adapter to let Read() share the same implementation with ReadToArray().
+void* DummyGetDataBuffer(void* user_data, uint32_t count, uint32_t size) {
+  return user_data;
+}
+
+}  // namespace
+
+namespace ppapi {
+namespace proxy {
+
+FileIOResource::FileIOResource(Connection connection, PP_Instance instance)
+    : PluginResource(connection, instance) {
+  SendCreate(RENDERER, PpapiHostMsg_FileIO_Create());
+}
+
+FileIOResource::~FileIOResource() {
+}
+
+PPB_FileIO_API* FileIOResource::AsPPB_FileIO_API() {
+  return this;
+}
+
+int32_t FileIOResource::Open(PP_Resource file_ref,
+                             int32_t open_flags,
+                             scoped_refptr<TrackedCallback> callback) {
+  EnterResourceNoLock<PPB_FileRef_API> enter(file_ref, true);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_EXCLUSIVE, false);
+  if (rv != PP_OK)
+    return rv;
+
+  Call<PpapiPluginMsg_FileIO_OpenReply>(RENDERER,
+      PpapiHostMsg_FileIO_Open(
+          enter.resource()->host_resource().host_resource(),
+          open_flags),
+      base::Bind(&FileIOResource::OnPluginMsgOpenFileComplete, this,
+                 callback));
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::Query(PP_FileInfo* info,
+                              scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_EXCLUSIVE, true);
+  if (rv != PP_OK)
+    return rv;
+
+  Call<PpapiPluginMsg_FileIO_QueryReply>(RENDERER,
+      PpapiHostMsg_FileIO_Query(),
+      base::Bind(&FileIOResource::OnPluginMsgQueryComplete, this,
+                 callback, info));
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::Touch(PP_Time last_access_time,
+                              PP_Time last_modified_time,
+                              scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_EXCLUSIVE, true);
+  if (rv != PP_OK)
+    return rv;
+
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+      PpapiHostMsg_FileIO_Touch(last_access_time, last_modified_time),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::Read(int64_t offset,
+                             char* buffer,
+                             int32_t bytes_to_read,
+                             scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_READ, true);
+  if (rv != PP_OK)
+    return rv;
+
+  PP_ArrayOutput output_adapter;
+  output_adapter.GetDataBuffer = &DummyGetDataBuffer;
+  output_adapter.user_data = buffer;
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_READ);
+  return ReadValidated(offset, bytes_to_read, output_adapter, callback);
+}
+
+int32_t FileIOResource::ReadToArray(int64_t offset,
+                                    int32_t max_read_length,
+                                    PP_ArrayOutput* array_output,
+                                    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(array_output);
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_READ, true);
+  if (rv != PP_OK)
+    return rv;
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_READ);
+  return ReadValidated(offset, max_read_length, *array_output, callback);
+}
+
+int32_t FileIOResource::Write(int64_t offset,
+                              const char* buffer,
+                              int32_t bytes_to_write,
+                              scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_WRITE, true);
+  if (rv != PP_OK)
+    return rv;
+
+  // TODO(brettw) it would be nice to use a shared memory buffer for large
+  // writes rather than having to copy to a string (which will involve a number
+  // of extra copies to serialize over IPC).
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+      PpapiHostMsg_FileIO_Write(offset, std::string(buffer, bytes_to_write)),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::SetLength(int64_t length,
+                                  scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_EXCLUSIVE, true);
+  if (rv != PP_OK)
+    return rv;
+
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+      PpapiHostMsg_FileIO_SetLength(length),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::Flush(scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = state_manager_.CheckOperationState(
+      FileIOStateManager::OPERATION_EXCLUSIVE, true);
+  if (rv != PP_OK)
+    return rv;
+
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+      PpapiHostMsg_FileIO_Flush(),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+
+  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;
+}
+
+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);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::WillSetLength(int64_t length,
+                                      scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+      PpapiHostMsg_FileIO_WillSetLength(length),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::ReadValidated(int64_t offset,
+                                      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;
+}
+
+void FileIOResource::OnPluginMsgGeneralComplete(
+    scoped_refptr<TrackedCallback> callback,
+    const ResourceMessageReplyParams& params) {
+  DCHECK(state_manager_.GetPendingOperation() ==
+             FileIOStateManager::OPERATION_EXCLUSIVE ||

[raymes, 2012/11/29 23:55:19]

Indentation here looks wrong. Please align with the opening "(" and the same for
all following lines.

[victorhsieh, 2012/11/30 01:17:21]

Done.

+         state_manager_.GetPendingOperation() ==
+             FileIOStateManager::OPERATION_WRITE);
+  callback->Run(params.result());
+  state_manager_.OperationFinished();
+}
+
+void FileIOResource::OnPluginMsgOpenFileComplete(
+    scoped_refptr<TrackedCallback> callback,
+    const ResourceMessageReplyParams& params) {
+  DCHECK(state_manager_.GetPendingOperation() ==
+             FileIOStateManager::OPERATION_EXCLUSIVE);

[raymes, 2012/11/29 23:55:19]

indentation

[victorhsieh, 2012/11/30 01:17:21]

Done.

+  if (params.result() == PP_OK)
+    state_manager_.SetOpenSucceed();
+  callback->Run(params.result());
+  state_manager_.OperationFinished();
+}
+
+void FileIOResource::OnPluginMsgQueryComplete(
+    scoped_refptr<TrackedCallback> callback,
+    PP_FileInfo* output_info,
+    const ResourceMessageReplyParams& params,
+    const PP_FileInfo& info) {
+  DCHECK(state_manager_.GetPendingOperation() ==
+             FileIOStateManager::OPERATION_EXCLUSIVE);

[raymes, 2012/11/29 23:55:19]

indentation

[victorhsieh, 2012/11/30 01:17:21]

Done.

+  *output_info = info;
+  callback->Run(params.result());
+  state_manager_.OperationFinished();
+}
+
+void FileIOResource::OnPluginMsgReadComplete(
+    scoped_refptr<TrackedCallback> callback,
+    PP_ArrayOutput array_output,
+    const ResourceMessageReplyParams& params,
+    const std::string& data) {
+  DCHECK(state_manager_.GetPendingOperation() ==
+             FileIOStateManager::OPERATION_READ);

[raymes, 2012/11/29 23:55:19]

indentation

[victorhsieh, 2012/11/30 01:17:21]

Done.

+
+  // The result code should contain the data size if it's positive.
+  int32_t result = params.result();
+  DCHECK((result < 0 && data.size() == 0) ||
+         result == static_cast<int32_t>(data.size()));
+
+  ArrayWriter output;
+  output.set_pp_array_output(array_output);
+  if (output.is_valid())
+    output.StoreArray(data.data(), std::max(0, result));
+  else
+    result = PP_ERROR_FAILED;
+
+  callback->Run(result);
+  state_manager_.OperationFinished();
+}
+
+}  // namespace proxy
+}  // namespace ppapi