Refactor FileIO to the new design

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"
+#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),
+      PPB_FileIO_Shared() {
+  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 = CommonPreCondition(false, OPERATION_EXCLUSIVE);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(OPERATION_EXCLUSIVE);
+  return OpenValidated(enter.resource(), enter.object(), open_flags, callback);

[raymes, 2012/11/28 18:39:35]

Again, please remove the "Validated" functions and just move the code into each
function, except for maybe "ReadValidated" where the function is used twice. You
could maybe name it "ReadHelper" though instead.

[victorhsieh, 2012/11/29 06:34:55]

Done.

+}
+
+int32_t FileIOResource::Query(PP_FileInfo* info,
+                              scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = CommonPreCondition(true, OPERATION_EXCLUSIVE);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(OPERATION_EXCLUSIVE);
+  return QueryValidated(info, callback);
+}
+
+int32_t FileIOResource::Touch(PP_Time last_access_time,
+                              PP_Time last_modified_time,
+                              scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = CommonPreCondition(true, OPERATION_EXCLUSIVE);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(OPERATION_EXCLUSIVE);
+  return TouchValidated(last_access_time, last_modified_time, callback);
+}
+
+int32_t FileIOResource::Read(int64_t offset,
+                             char* buffer,
+                             int32_t bytes_to_read,
+                             scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = CommonPreCondition(true, OPERATION_READ);
+  if (rv != PP_OK)
+    return rv;
+
+  PP_ArrayOutput output_adapter;
+  output_adapter.GetDataBuffer = &DummyGetDataBuffer;
+  output_adapter.user_data = buffer;
+  CommonPostCondition(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 = CommonPreCondition(true, OPERATION_READ);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(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 = CommonPreCondition(true, OPERATION_WRITE);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(OPERATION_WRITE);
+  return WriteValidated(offset, buffer, bytes_to_write, callback);
+}
+
+int32_t FileIOResource::SetLength(int64_t length,
+                                  scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = CommonPreCondition(true, OPERATION_EXCLUSIVE);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(OPERATION_EXCLUSIVE);
+  return SetLengthValidated(length, callback);
+}
+
+int32_t FileIOResource::Flush(scoped_refptr<TrackedCallback> callback) {
+  int32_t rv = CommonPreCondition(true, OPERATION_EXCLUSIVE);
+  if (rv != PP_OK)
+    return rv;
+
+  CommonPostCondition(OPERATION_EXCLUSIVE);
+  return FlushValidated(callback);
+}
+
+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_GeneralComplete>(RENDERER,
+      PpapiHostMsg_FileIO_WillWrite(offset, bytes_to_write),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  SetOpInProgress(OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::WillSetLength(int64_t length,
+                                      scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_GeneralComplete>(RENDERER,
+      PpapiHostMsg_FileIO_WillSetLength(length),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  SetOpInProgress(OPERATION_EXCLUSIVE);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::OpenValidated(Resource* file_ref_resource,
+                                      PPB_FileRef_API* file_ref_api,
+                                      int32_t open_flags,
+                                      scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_OpenFileComplete>(RENDERER,
+      PpapiHostMsg_FileIO_Open(
+          file_ref_resource->host_resource().host_resource(),
+          open_flags),
+      base::Bind(&FileIOResource::OnPluginMsgOpenFileComplete, this,
+                 callback));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::QueryValidated(
+    PP_FileInfo* info,
+    scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_QueryComplete>(RENDERER,
+      PpapiHostMsg_FileIO_Query(),
+      base::Bind(&FileIOResource::OnPluginMsgQueryComplete, this,
+                 callback, info));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::TouchValidated(
+    PP_Time last_access_time,
+    PP_Time last_modified_time,
+    scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_GeneralComplete>(RENDERER,
+      PpapiHostMsg_FileIO_Touch(last_access_time, last_modified_time),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  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_ReadComplete>(RENDERER,
+      PpapiHostMsg_FileIO_Read(offset, bytes_to_read),
+      base::Bind(&FileIOResource::OnPluginMsgReadComplete, this,
+                 callback, array_output));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::WriteValidated(
+    int64_t offset,
+    const char* buffer,
+    int32_t bytes_to_write,
+    scoped_refptr<TrackedCallback> callback) {
+  // 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_GeneralComplete>(RENDERER,
+      PpapiHostMsg_FileIO_Write(offset, std::string(buffer, bytes_to_write)),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::SetLengthValidated(
+    int64_t length,
+    scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_GeneralComplete>(RENDERER,
+      PpapiHostMsg_FileIO_SetLength(length),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t FileIOResource::FlushValidated(
+    scoped_refptr<TrackedCallback> callback) {
+  Call<PpapiPluginMsg_FileIO_GeneralComplete>(RENDERER,
+      PpapiHostMsg_FileIO_Flush(),
+      base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
+                 callback));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void FileIOResource::OnPluginMsgGeneralComplete(
+    scoped_refptr<TrackedCallback> callback,
+    const ResourceMessageReplyParams& params) {
+  DCHECK(pending_op_ == OPERATION_EXCLUSIVE ||
+         pending_op_ == OPERATION_WRITE);
+  callback->Run(params.result());
+  SetOpFinished();
+}
+
+void FileIOResource::OnPluginMsgOpenFileComplete(
+    scoped_refptr<TrackedCallback> callback,
+    const ResourceMessageReplyParams& params) {
+  DCHECK(pending_op_ == OPERATION_EXCLUSIVE);
+  if (params.result() == PP_OK)
+    SetOpenSucceed();
+  callback->Run(params.result());
+  SetOpFinished();
+}
+
+void FileIOResource::OnPluginMsgQueryComplete(
+    scoped_refptr<TrackedCallback> callback,
+    PP_FileInfo* output_info,
+    const ResourceMessageReplyParams& params,
+    const PP_FileInfo& info) {
+  DCHECK(pending_op_ == OPERATION_EXCLUSIVE);
+  *output_info = info;
+  callback->Run(params.result());
+  SetOpFinished();
+}
+
+void FileIOResource::OnPluginMsgReadComplete(
+    scoped_refptr<TrackedCallback> callback,
+    PP_ArrayOutput array_output,
+    const ResourceMessageReplyParams& params,
+    const std::string& data) {
+  DCHECK(pending_op_ == OPERATION_READ);
+
+  // 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);
+  SetOpFinished();
+}
+
+}  // namespace proxy
+}  // namespace ppapi