// Copyright (c) 2011 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 "webkit/plugins/ppapi/ppb_file_io_impl.h"

#include "base/bind.h"
#include "base/callback.h"
#include "base/file_util.h"
#include "base/file_util_proxy.h"
#include "base/message_loop_proxy.h"
#include "base/platform_file.h"
#include "base/logging.h"
#include "base/time.h"
#include "ppapi/c/ppb_file_io.h"
#include "ppapi/c/trusted/ppb_file_io_trusted.h"
#include "ppapi/c/pp_completion_callback.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/shared_impl/file_type_conversion.h"
#include "ppapi/shared_impl/time_conversion.h"
#include "ppapi/thunk/enter.h"
#include "ppapi/thunk/ppb_file_ref_api.h"
#include "webkit/plugins/ppapi/common.h"
#include "webkit/plugins/ppapi/plugin_module.h"
#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
#include "webkit/plugins/ppapi/ppb_file_ref_impl.h"
#include "webkit/plugins/ppapi/quota_file_io.h"
#include "webkit/plugins/ppapi/resource_helper.h"

using ppapi::PPTimeToTime;
using ppapi::TimeToPPTime;
using ppapi::thunk::PPB_FileRef_API;

namespace webkit {
namespace ppapi {

PPB_FileIO_Impl::PPB_FileIO_Impl(PP_Instance instance)
    : ::ppapi::PPB_FileIO_Shared(instance),
      file_(base::kInvalidPlatformFileValue),
      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
}

PPB_FileIO_Impl::~PPB_FileIO_Impl() {
  Close();
}

int32_t PPB_FileIO_Impl::OpenValidated(PP_Resource file_ref_resource,
                                       PPB_FileRef_API* file_ref_api,
                                       int32_t open_flags,
                                       PP_CompletionCallback callback) {
  PPB_FileRef_Impl* file_ref = static_cast<PPB_FileRef_Impl*>(file_ref_api);

  int flags = 0;
  if (!::ppapi::PepperFileOpenFlagsToPlatformFileFlags(open_flags, &flags))
    return PP_ERROR_BADARGUMENT;

  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_BADARGUMENT;

  if (file_ref->HasValidFileSystem()) {
    file_system_url_ = file_ref->GetFileSystemURL();
    if (!plugin_delegate->AsyncOpenFileSystemURL(
            file_system_url_, flags,
            base::Bind(&PPB_FileIO_Impl::ExecutePlatformOpenFileCallback,
                       weak_factory_.GetWeakPtr())))
      return PP_ERROR_FAILED;
  } else {
    if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL)
      return PP_ERROR_FAILED;
    if (!plugin_delegate->AsyncOpenFile(
            file_ref->GetSystemPath(), flags,
            base::Bind(&PPB_FileIO_Impl::ExecutePlatformOpenFileCallback,
                       weak_factory_.GetWeakPtr())))
      return PP_ERROR_FAILED;
  }

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::QueryValidated(PP_FileInfo* info,
                                        PP_CompletionCallback callback) {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_FAILED;

  if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
          plugin_delegate->GetFileThreadMessageLoopProxy(), file_,
          base::Bind(&PPB_FileIO_Impl::ExecutePlatformQueryCallback,
                     weak_factory_.GetWeakPtr())))
    return PP_ERROR_FAILED;

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, info);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::TouchValidated(PP_Time last_access_time,
                                        PP_Time last_modified_time,
                                        PP_CompletionCallback callback) {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_FAILED;

  if (!base::FileUtilProxy::Touch(
          plugin_delegate->GetFileThreadMessageLoopProxy(),
          file_, PPTimeToTime(last_access_time),
          PPTimeToTime(last_modified_time),
          base::Bind(&PPB_FileIO_Impl::ExecutePlatformGeneralCallback,
                     weak_factory_.GetWeakPtr())))
    return PP_ERROR_FAILED;

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::ReadValidated(int64_t offset,
                                       char* buffer,
                                       int32_t bytes_to_read,
                                       PP_CompletionCallback callback) {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_FAILED;

  if (!base::FileUtilProxy::Read(
          plugin_delegate->GetFileThreadMessageLoopProxy(), file_, offset,
          bytes_to_read,
          base::Bind(&PPB_FileIO_Impl::ExecutePlatformReadCallback,
                     weak_factory_.GetWeakPtr())))
    return PP_ERROR_FAILED;

  RegisterCallback(OPERATION_READ, callback, buffer, NULL);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::WriteValidated(int64_t offset,
                                        const char* buffer,
                                        int32_t bytes_to_write,
                                        PP_CompletionCallback callback) {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_FAILED;

  if (quota_file_io_.get()) {
    if (!quota_file_io_->Write(
            offset, buffer, bytes_to_write,
            base::Bind(&PPB_FileIO_Impl::ExecutePlatformWriteCallback,
                       weak_factory_.GetWeakPtr())))
      return PP_ERROR_FAILED;
  } else {
    if (!base::FileUtilProxy::Write(
            plugin_delegate->GetFileThreadMessageLoopProxy(), file_, offset,
            buffer, bytes_to_write,
            base::Bind(&PPB_FileIO_Impl::ExecutePlatformWriteCallback,
                       weak_factory_.GetWeakPtr())))
      return PP_ERROR_FAILED;
  }

  RegisterCallback(OPERATION_WRITE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::SetLengthValidated(int64_t length,
                                            PP_CompletionCallback callback) {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_FAILED;

  if (quota_file_io_.get()) {
    if (!quota_file_io_->SetLength(
            length,
            base::Bind(&PPB_FileIO_Impl::ExecutePlatformGeneralCallback,
                       weak_factory_.GetWeakPtr())))
      return PP_ERROR_FAILED;
  } else {
    if (!base::FileUtilProxy::Truncate(
            plugin_delegate->GetFileThreadMessageLoopProxy(), file_, length,
            base::Bind(&PPB_FileIO_Impl::ExecutePlatformGeneralCallback,
                       weak_factory_.GetWeakPtr())))
      return PP_ERROR_FAILED;
  }

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::FlushValidated(PP_CompletionCallback callback) {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (!plugin_delegate)
    return PP_ERROR_FAILED;

  if (!base::FileUtilProxy::Flush(
          plugin_delegate->GetFileThreadMessageLoopProxy(), file_,
          base::Bind(&PPB_FileIO_Impl::ExecutePlatformGeneralCallback,
                     weak_factory_.GetWeakPtr())))
    return PP_ERROR_FAILED;

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

void PPB_FileIO_Impl::Close() {
  PluginDelegate* plugin_delegate = GetPluginDelegate();
  if (file_ != base::kInvalidPlatformFileValue && plugin_delegate) {
    base::FileUtilProxy::Close(
        plugin_delegate->GetFileThreadMessageLoopProxy(), file_,
        base::FileUtilProxy::StatusCallback());
    file_ = base::kInvalidPlatformFileValue;
    quota_file_io_.reset();
  }
}

int32_t PPB_FileIO_Impl::GetOSFileDescriptor() {
#if defined(OS_POSIX)
  return file_;
#elif defined(OS_WIN)
  return reinterpret_cast<uintptr_t>(file_);
#else
#error "Platform not supported."
#endif
}

int32_t PPB_FileIO_Impl::WillWrite(int64_t offset,
                                   int32_t bytes_to_write,
                                   PP_CompletionCallback callback) {
  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
  if (rv != PP_OK)
    return rv;

  if (!quota_file_io_.get())
    return PP_OK;

  if (!quota_file_io_->WillWrite(
          offset, bytes_to_write,
          base::Bind(&PPB_FileIO_Impl::ExecutePlatformWillWriteCallback,
                     weak_factory_.GetWeakPtr())))
    return PP_ERROR_FAILED;

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_FileIO_Impl::WillSetLength(int64_t length,
                                       PP_CompletionCallback callback) {
  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
  if (rv != PP_OK)
    return rv;

  if (!quota_file_io_.get())
    return PP_OK;

  if (!quota_file_io_->WillSetLength(
          length,
          base::Bind(&PPB_FileIO_Impl::ExecutePlatformGeneralCallback,
                     weak_factory_.GetWeakPtr())))
    return PP_ERROR_FAILED;

  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
  return PP_OK_COMPLETIONPENDING;
}

PluginDelegate* PPB_FileIO_Impl::GetPluginDelegate() {
  return ResourceHelper::GetPluginDelegate(this);
}

void PPB_FileIO_Impl::ExecutePlatformGeneralCallback(
    base::PlatformFileError error_code) {
  ExecuteGeneralCallback(::ppapi::PlatformFileErrorToPepperError(error_code));
}

void PPB_FileIO_Impl::ExecutePlatformOpenFileCallback(
    base::PlatformFileError error_code,
    base::PassPlatformFile file) {
  DCHECK(file_ == base::kInvalidPlatformFileValue);
  file_ = file.ReleaseValue();

  DCHECK(!quota_file_io_.get());
  if (file_ != base::kInvalidPlatformFileValue &&
      (file_system_type_ == PP_FILESYSTEMTYPE_LOCALTEMPORARY ||
       file_system_type_ == PP_FILESYSTEMTYPE_LOCALPERSISTENT)) {
    quota_file_io_.reset(new QuotaFileIO(
        pp_instance(), file_, file_system_url_, file_system_type_));
  }

  ExecuteOpenFileCallback(::ppapi::PlatformFileErrorToPepperError(error_code));
}

void PPB_FileIO_Impl::ExecutePlatformQueryCallback(
    base::PlatformFileError error_code,
    const base::PlatformFileInfo& file_info) {
  PP_FileInfo pp_info;
  pp_info.size = file_info.size;
  pp_info.creation_time = TimeToPPTime(file_info.creation_time);
  pp_info.last_access_time = TimeToPPTime(file_info.last_accessed);
  pp_info.last_modified_time = TimeToPPTime(file_info.last_modified);
  pp_info.system_type = file_system_type_;
  if (file_info.is_directory)
    pp_info.type = PP_FILETYPE_DIRECTORY;
  else
    pp_info.type = PP_FILETYPE_REGULAR;

  ExecuteQueryCallback(::ppapi::PlatformFileErrorToPepperError(error_code),
                       pp_info);
}

void PPB_FileIO_Impl::ExecutePlatformReadCallback(
    base::PlatformFileError error_code,
    const char* data, int bytes_read) {
  // Map the error code, OK getting mapped to the # of bytes read.
  int32_t pp_result = ::ppapi::PlatformFileErrorToPepperError(error_code);
  pp_result = pp_result == PP_OK ? bytes_read : pp_result;
  ExecuteReadCallback(pp_result, data);
}

void PPB_FileIO_Impl::ExecutePlatformWriteCallback(
    base::PlatformFileError error_code,
    int bytes_written) {
  int32_t pp_result = ::ppapi::PlatformFileErrorToPepperError(error_code);
  ExecuteGeneralCallback(pp_result == PP_OK ? bytes_written : pp_result);
}

void PPB_FileIO_Impl::ExecutePlatformWillWriteCallback(
    base::PlatformFileError error_code,
    int bytes_written) {
  if (pending_op_ != OPERATION_EXCLUSIVE || callbacks_.empty()) {
    NOTREACHED();
    return;
  }

  if (error_code != base::PLATFORM_FILE_OK) {
    RunAndRemoveFirstPendingCallback(
        ::ppapi::PlatformFileErrorToPepperError(error_code));
  } else {
    RunAndRemoveFirstPendingCallback(bytes_written);
  }
}

}  // namespace ppapi
}  // namespace webkit