// 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/fileapi/file_system_operation.h"

#include "base/bind.h"
#include "base/time.h"
#include "base/utf_string_conversions.h"
#include "net/base/escape.h"
#include "net/url_request/url_request_context.h"
#include "webkit/fileapi/file_system_callback_dispatcher.h"
#include "webkit/fileapi/file_system_context.h"
#include "webkit/fileapi/file_system_file_util_proxy.h"
#include "webkit/fileapi/file_system_operation_context.h"
#include "webkit/fileapi/file_system_path_manager.h"
#include "webkit/fileapi/file_system_quota_util.h"
#include "webkit/fileapi/file_system_types.h"
#include "webkit/fileapi/file_system_util.h"
#include "webkit/fileapi/file_writer_delegate.h"
#include "webkit/fileapi/local_file_util.h"
#include "webkit/fileapi/quota_file_util.h"
#include "webkit/quota/quota_types.h"

namespace fileapi {

class FileSystemOperation::ScopedQuotaUtilHelper {
 public:
  ScopedQuotaUtilHelper(FileSystemContext* context,
                        const GURL& origin_url,
                        FileSystemType type);
  ~ScopedQuotaUtilHelper();

 private:
  FileSystemQuotaUtil* quota_util_;
  const GURL& origin_url_;
  FileSystemType type_;
  DISALLOW_COPY_AND_ASSIGN(ScopedQuotaUtilHelper);
};

FileSystemOperation::ScopedQuotaUtilHelper::ScopedQuotaUtilHelper(
    FileSystemContext* context, const GURL& origin_url, FileSystemType type)
    : origin_url_(origin_url), type_(type) {
  DCHECK(context);
  DCHECK(type != kFileSystemTypeUnknown);
  quota_util_ = context->GetQuotaUtil(type_);
  if (quota_util_) {
    DCHECK(quota_util_->proxy());
    quota_util_->proxy()->StartUpdateOrigin(origin_url_, type_);
  }
}

FileSystemOperation::ScopedQuotaUtilHelper::~ScopedQuotaUtilHelper() {
  if (quota_util_) {
    DCHECK(quota_util_->proxy());
    quota_util_->proxy()->EndUpdateOrigin(origin_url_, type_);
  }
}

FileSystemOperation::FileSystemOperation(
    FileSystemCallbackDispatcher* dispatcher,
    scoped_refptr<base::MessageLoopProxy> proxy,
    FileSystemContext* file_system_context)
    : proxy_(proxy),
      dispatcher_(dispatcher),
      operation_context_(file_system_context, NULL) {
#ifndef NDEBUG
  pending_operation_ = kOperationNone;
#endif
}

FileSystemOperation::~FileSystemOperation() {
  if (file_writer_delegate_.get()) {
    FileSystemOperationContext* c =
        new FileSystemOperationContext(operation_context_);
    base::FileUtilProxy::RelayClose(
        proxy_,
        base::Bind(&FileSystemFileUtil::Close,
                   base::Unretained(c->src_file_util()),
                   base::Owned(c)),
        file_writer_delegate_->file(),
        base::FileUtilProxy::StatusCallback());
  }
}

void FileSystemOperation::OpenFileSystem(
    const GURL& origin_url, fileapi::FileSystemType type, bool create) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = static_cast<FileSystemOperation::OperationType>(
      kOperationOpenFileSystem);
#endif

  DCHECK(file_system_context());
  operation_context_.set_src_origin_url(origin_url);
  operation_context_.set_src_type(type);
  // TODO(ericu): We don't really need to make this call if !create.
  // Also, in the future we won't need it either way, as long as we do all
  // permission+quota checks beforehand.  We only need it now because we have to
  // create an unpredictable directory name.  Without that, we could lazily
  // create the root later on the first filesystem write operation, and just
  // return GetFileSystemRootURI() here.
  file_system_context()->path_manager()->ValidateFileSystemRootAndGetURL(
      origin_url, type, create,
      base::Bind(&FileSystemOperation::DidGetRootPath,
                 base::Owned(this)));
}

void FileSystemOperation::CreateFile(const GURL& path,
                                     bool exclusive) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationCreateFile;
#endif
  if (!SetupSrcContextForWrite(path, true)) {
    delete this;
    return;
  }
  GetUsageAndQuotaThenCallback(
      operation_context_.src_origin_url(),
      base::Bind(&FileSystemOperation::DelayedCreateFileForQuota,
                 base::Unretained(this), exclusive));
}

void FileSystemOperation::DelayedCreateFileForQuota(
    bool exclusive,
    quota::QuotaStatusCode status, int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.src_origin_url(),
      operation_context_.src_type()));

  FileSystemFileUtilProxy::RelayEnsureFileExists(
      proxy_,
      base::Bind(&FileSystemFileUtil::EnsureFileExists,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_),
      base::Bind(
          exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
                    : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
          base::Owned(this)));
}

void FileSystemOperation::CreateDirectory(const GURL& path,
                                          bool exclusive,
                                          bool recursive) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationCreateDirectory;
#endif
  if (!SetupSrcContextForWrite(path, true)) {
    delete this;
    return;
  }
  GetUsageAndQuotaThenCallback(
      operation_context_.src_origin_url(),
      base::Bind(&FileSystemOperation::DelayedCreateDirectoryForQuota,
                 base::Unretained(this), exclusive, recursive));
}

void FileSystemOperation::DelayedCreateDirectoryForQuota(
    bool exclusive, bool recursive,
    quota::QuotaStatusCode status, int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.src_origin_url(),
      operation_context_.src_type()));

  base::FileUtilProxy::RelayFileTask(
      proxy_, FROM_HERE,
      base::Bind(&FileSystemFileUtil::CreateDirectory,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_,
                 src_virtual_path_, exclusive, recursive),
      base::Bind(&FileSystemOperation::DidFinishFileOperation,
                 base::Owned(this)));
}

void FileSystemOperation::Copy(const GURL& src_path,
                               const GURL& dest_path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationCopy;
#endif
  if (!SetupSrcContextForRead(src_path) ||
      !SetupDestContextForWrite(dest_path, true)) {
    delete this;
    return;
  }

  GetUsageAndQuotaThenCallback(
      operation_context_.dest_origin_url(),
      base::Bind(&FileSystemOperation::DelayedCopyForQuota,
                 base::Unretained(this)));
}

void FileSystemOperation::DelayedCopyForQuota(quota::QuotaStatusCode status,
                                              int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.dest_origin_url(),
      operation_context_.dest_type()));

  base::FileUtilProxy::RelayFileTask(
      proxy_, FROM_HERE,
      base::Bind(&FileSystemFileUtil::Copy,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_,
                 src_virtual_path_, dest_virtual_path_),
      base::Bind(&FileSystemOperation::DidFinishFileOperation,
                 base::Owned(this)));
}

void FileSystemOperation::Move(const GURL& src_path,
                               const GURL& dest_path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationMove;
#endif
  if (!SetupSrcContextForWrite(src_path, false) ||
      !SetupDestContextForWrite(dest_path, true)) {
    delete this;
    return;
  }

  GetUsageAndQuotaThenCallback(
      operation_context_.dest_origin_url(),
      base::Bind(&FileSystemOperation::DelayedMoveForQuota,
                 base::Unretained(this)));
}

void FileSystemOperation::DelayedMoveForQuota(quota::QuotaStatusCode status,
                                              int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.dest_origin_url(),
      operation_context_.dest_type()));

  base::FileUtilProxy::RelayFileTask(
      proxy_, FROM_HERE,
      base::Bind(&FileSystemFileUtil::Move,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_,
                 src_virtual_path_, dest_virtual_path_),
      base::Bind(&FileSystemOperation::DidFinishFileOperation,
                 base::Owned(this)));
}

void FileSystemOperation::DirectoryExists(const GURL& path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationDirectoryExists;
#endif
  if (!SetupSrcContextForRead(path)) {
    delete this;
    return;
  }

  FileSystemFileUtilProxy::RelayGetFileInfo(
      proxy_,
      base::Bind(&FileSystemFileUtil::GetFileInfo,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_),
      base::Bind(&FileSystemOperation::DidDirectoryExists, base::Owned(this)));
}

void FileSystemOperation::FileExists(const GURL& path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationFileExists;
#endif
  if (!SetupSrcContextForRead(path)) {
    delete this;
    return;
  }

  FileSystemFileUtilProxy::RelayGetFileInfo(
      proxy_,
      base::Bind(&FileSystemFileUtil::GetFileInfo,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_),
      base::Bind(&FileSystemOperation::DidFileExists, base::Owned(this)));
}

void FileSystemOperation::GetMetadata(const GURL& path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationGetMetadata;
#endif
  if (!SetupSrcContextForRead(path)) {
    delete this;
    return;
  }

  FileSystemFileUtilProxy::RelayGetFileInfo(
      proxy_,
      base::Bind(&FileSystemFileUtil::GetFileInfo,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_),
      base::Bind(&FileSystemOperation::DidGetMetadata, base::Owned(this)));
}

void FileSystemOperation::ReadDirectory(const GURL& path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationReadDirectory;
#endif
  if (!SetupSrcContextForRead(path)) {
    delete this;
    return;
  }

  FileSystemFileUtilProxy::RelayReadDirectory(
      proxy_,
      base::Bind(&FileSystemFileUtil::ReadDirectory,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_),
      base::Bind(&FileSystemOperation::DidReadDirectory, base::Owned(this)));
}

void FileSystemOperation::Remove(const GURL& path, bool recursive) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationRemove;
#endif
  if (!SetupSrcContextForWrite(path, false)) {
    delete this;
    return;
  }

  base::FileUtilProxy::RelayFileTask(
      proxy_, FROM_HERE,
      base::Bind(&FileSystemFileUtil::Delete,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_, recursive),
      base::Bind(&FileSystemOperation::DidFinishFileOperation,
                 base::Owned(this)));
}

void FileSystemOperation::Write(
    scoped_refptr<net::URLRequestContext> url_request_context,
    const GURL& path,
    const GURL& blob_url,
    int64 offset) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationWrite;
#endif
  if (!SetupSrcContextForWrite(path, true)) {
    delete this;
    return;
  }
  DCHECK(blob_url.is_valid());
  file_writer_delegate_.reset(new FileWriterDelegate(this, offset, proxy_));
  blob_request_.reset(
      new net::URLRequest(blob_url, file_writer_delegate_.get()));
  blob_request_->set_context(url_request_context);

  GetUsageAndQuotaThenCallback(
      operation_context_.src_origin_url(),
      base::Bind(&FileSystemOperation::DelayedWriteForQuota,
                 base::Unretained(this)));
}

void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.src_origin_url(),
      operation_context_.src_type()));

  int file_flags = base::PLATFORM_FILE_OPEN |
                   base::PLATFORM_FILE_WRITE |
                   base::PLATFORM_FILE_ASYNC;

  base::FileUtilProxy::RelayCreateOrOpen(
      proxy_,
      base::Bind(&FileSystemFileUtil::CreateOrOpen,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_, file_flags),
      base::Bind(&FileSystemFileUtil::Close,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_),
      base::Bind(&FileSystemOperation::OnFileOpenedForWrite,
                 base::Unretained(this)));
}

void FileSystemOperation::Truncate(const GURL& path, int64 length) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationTruncate;
#endif
  if (!SetupSrcContextForWrite(path, false)) {
    delete this;
    return;
  }
  GetUsageAndQuotaThenCallback(
      operation_context_.src_origin_url(),
      base::Bind(&FileSystemOperation::DelayedTruncateForQuota,
                 base::Unretained(this), length));
}

void FileSystemOperation::DelayedTruncateForQuota(int64 length,
                                                  quota::QuotaStatusCode status,
                                                  int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.src_origin_url(),
      operation_context_.src_type()));

  base::FileUtilProxy::RelayFileTask(
      proxy_, FROM_HERE,
      base::Bind(&FileSystemFileUtil::Truncate,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_, src_virtual_path_, length),
      base::Bind(&FileSystemOperation::DidFinishFileOperation,
                 base::Owned(this)));
}

void FileSystemOperation::TouchFile(const GURL& path,
                                    const base::Time& last_access_time,
                                    const base::Time& last_modified_time) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationTouchFile;
#endif
  if (!SetupSrcContextForWrite(path, true)) {
    delete this;
    return;
  }

  base::FileUtilProxy::RelayFileTask(
      proxy_, FROM_HERE,
      base::Bind(&FileSystemFileUtil::Touch,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_,
                 src_virtual_path_, last_access_time, last_modified_time),
      base::Bind(&FileSystemOperation::DidTouchFile, base::Owned(this)));
}

void FileSystemOperation::OpenFile(const GURL& path,
                                   int file_flags,
                                   base::ProcessHandle peer_handle) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationOpenFile;
#endif
  peer_handle_ = peer_handle;

  if (file_flags & (
      (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
       base::PLATFORM_FILE_HIDDEN))) {
    delete this;
    return;
  }
  if (file_flags &
      (base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_OPEN_ALWAYS |
       base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_TRUNCATED |
       base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE |
       base::PLATFORM_FILE_DELETE_ON_CLOSE |
       base::PLATFORM_FILE_WRITE_ATTRIBUTES)) {
    if (!SetupSrcContextForWrite(path, true)) {
      delete this;
      return;
    }
  } else {
    if (!SetupSrcContextForRead(path)) {
      delete this;
      return;
    }
  }
  GetUsageAndQuotaThenCallback(
      operation_context_.src_origin_url(),
      base::Bind(&FileSystemOperation::DelayedOpenFileForQuota,
                 base::Unretained(this), file_flags));
}

void FileSystemOperation::DelayedOpenFileForQuota(int file_flags,
                                                  quota::QuotaStatusCode status,
                                                  int64 usage, int64 quota) {
  operation_context_.set_allowed_bytes_growth(quota - usage);

  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
      file_system_context(),
      operation_context_.src_origin_url(),
      operation_context_.src_type()));

  base::FileUtilProxy::RelayCreateOrOpen(
      proxy_,
      base::Bind(&FileSystemFileUtil::CreateOrOpen,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_,
                 src_virtual_path_, file_flags),
      base::Bind(&FileSystemFileUtil::Close,
                 base::Unretained(operation_context_.src_file_util()),
                 &operation_context_),
      base::Bind(&FileSystemOperation::DidOpenFile, base::Owned(this)));
}

void FileSystemOperation::SyncGetPlatformPath(const GURL& path,
                                              FilePath* platform_path) {
#ifndef NDEBUG
  DCHECK(kOperationNone == pending_operation_);
  pending_operation_ = kOperationGetLocalPath;
#endif
  if (!SetupSrcContextForRead(path)) {
    delete this;
    return;
  }

  operation_context_.src_file_util()->GetLocalFilePath(
      &operation_context_, src_virtual_path_, platform_path);

  delete this;
}

// We can only get here on a write or truncate that's not yet completed.
// We don't support cancelling any other operation at this time.
void FileSystemOperation::Cancel(FileSystemOperation* cancel_operation_ptr) {
  scoped_ptr<FileSystemOperation> cancel_operation(cancel_operation_ptr);
  if (file_writer_delegate_.get()) {
#ifndef NDEBUG
    DCHECK(kOperationWrite == pending_operation_);
#endif
    // Writes are done without proxying through FileUtilProxy after the initial
    // opening of the PlatformFile.  All state changes are done on this thread,
    // so we're guaranteed to be able to shut down atomically.  We do need to
    // check that the file has been opened [which means the blob_request_ has
    // been created], so we know how much we need to do.
    if (blob_request_.get())
      // This halts any calls to file_writer_delegate_ from blob_request_.
      blob_request_->Cancel();

    if (dispatcher_.get())
      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
    cancel_operation->dispatcher_->DidSucceed();
    dispatcher_.reset();
  } else {
#ifndef NDEBUG
    DCHECK(kOperationTruncate == pending_operation_);
#endif
    // We're cancelling a truncate operation, but we can't actually stop it
    // since it's been proxied to another thread.  We need to save the
    // cancel_operation so that when the truncate returns, it can see that it's
    // been cancelled, report it, and report that the cancel has succeeded.
    DCHECK(!cancel_operation_.get());
    cancel_operation_.swap(cancel_operation);
  }
}

void FileSystemOperation::GetUsageAndQuotaThenCallback(
    const GURL& origin_url,
    const quota::QuotaManager::GetUsageAndQuotaCallback& callback) {
  quota::QuotaManagerProxy* quota_manager_proxy =
      file_system_context()->quota_manager_proxy();
  if (!quota_manager_proxy ||
      !file_system_context()->GetQuotaUtil(
          operation_context_.src_type())) {
    // If we don't have the quota manager or the requested filesystem type
    // does not support quota, we should be able to let it go.
    callback.Run(quota::kQuotaStatusOk, 0, kint64max);
    return;
  }
  DCHECK(quota_manager_proxy);
  DCHECK(quota_manager_proxy->quota_manager());
  quota_manager_proxy->quota_manager()->GetUsageAndQuota(
      operation_context_.src_origin_url(),
      FileSystemTypeToQuotaStorageType(
          operation_context_.src_type()),
      callback);
}

void FileSystemOperation::DidGetRootPath(
    bool success,
    const FilePath& path, const std::string& name) {
  if (!dispatcher_.get())
    return;
  DCHECK(success || path.empty());
  GURL result;
  if (!dispatcher_.get())
    return;
  // We ignore the path, and return a URL instead.  The point was just to verify
  // that we could create/find the path.
  if (success) {
    result = GetFileSystemRootURI(
        operation_context_.src_origin_url(),
        operation_context_.src_type());
  }
  dispatcher_->DidOpenFileSystem(name, result);
}

void FileSystemOperation::DidEnsureFileExistsExclusive(
    base::PlatformFileError rv, bool created) {
  if (rv == base::PLATFORM_FILE_OK && !created) {
    if (dispatcher_.get())
      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_EXISTS);
  } else {
    DidFinishFileOperation(rv);
  }
}

void FileSystemOperation::DidEnsureFileExistsNonExclusive(
    base::PlatformFileError rv, bool /* created */) {
  DidFinishFileOperation(rv);
}

void FileSystemOperation::DidFinishFileOperation(
    base::PlatformFileError rv) {
  if (cancel_operation_.get()) {
#ifndef NDEBUG
    DCHECK(kOperationTruncate == pending_operation_);
#endif

    if (dispatcher_.get())
      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
    cancel_operation_->dispatcher_->DidSucceed();
  } else if (dispatcher_.get()) {
    if (rv == base::PLATFORM_FILE_OK)
      dispatcher_->DidSucceed();
    else
      dispatcher_->DidFail(rv);
  }
}

void FileSystemOperation::DidDirectoryExists(
    base::PlatformFileError rv,
    const base::PlatformFileInfo& file_info,
    const FilePath& unused) {
  if (!dispatcher_.get())
    return;
  if (rv == base::PLATFORM_FILE_OK) {
    if (file_info.is_directory)
      dispatcher_->DidSucceed();
    else
      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY);
  } else {
    dispatcher_->DidFail(rv);
  }
}

void FileSystemOperation::DidFileExists(
    base::PlatformFileError rv,
    const base::PlatformFileInfo& file_info,
    const FilePath& unused) {
  if (!dispatcher_.get())
    return;
  if (rv == base::PLATFORM_FILE_OK) {
    if (file_info.is_directory)
      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NOT_A_FILE);
    else
      dispatcher_->DidSucceed();
  } else {
    dispatcher_->DidFail(rv);
  }
}

void FileSystemOperation::DidGetMetadata(
    base::PlatformFileError rv,
    const base::PlatformFileInfo& file_info,
    const FilePath& platform_path) {
  if (!dispatcher_.get())
    return;
  if (rv == base::PLATFORM_FILE_OK)
    dispatcher_->DidReadMetadata(file_info, platform_path);
  else
    dispatcher_->DidFail(rv);
}

void FileSystemOperation::DidReadDirectory(
    base::PlatformFileError rv,
    const std::vector<base::FileUtilProxy::Entry>& entries) {
  if (!dispatcher_.get())
    return;

  if (rv == base::PLATFORM_FILE_OK)
    dispatcher_->DidReadDirectory(entries, false /* has_more */);
  else
    dispatcher_->DidFail(rv);
}

void FileSystemOperation::DidWrite(
    base::PlatformFileError rv,
    int64 bytes,
    bool complete) {
  if (!dispatcher_.get()) {
    delete this;
    return;
  }
  if (rv == base::PLATFORM_FILE_OK)
    dispatcher_->DidWrite(bytes, complete);
  else
    dispatcher_->DidFail(rv);
  if (complete || rv != base::PLATFORM_FILE_OK)
    delete this;
}

void FileSystemOperation::DidTouchFile(base::PlatformFileError rv) {
  if (!dispatcher_.get())
    return;
  if (rv == base::PLATFORM_FILE_OK)
    dispatcher_->DidSucceed();
  else
    dispatcher_->DidFail(rv);
}

void FileSystemOperation::DidOpenFile(
    base::PlatformFileError rv,
    base::PassPlatformFile file,
    bool unused) {
  if (!dispatcher_.get())
    return;
  if (rv == base::PLATFORM_FILE_OK)
    dispatcher_->DidOpenFile(file.ReleaseValue(), peer_handle_);
  else
    dispatcher_->DidFail(rv);
}

void FileSystemOperation::OnFileOpenedForWrite(
    base::PlatformFileError rv,
    base::PassPlatformFile file,
    bool created) {
  if (base::PLATFORM_FILE_OK != rv || !dispatcher_.get()) {
    if (dispatcher_.get())
      dispatcher_->DidFail(rv);
    delete this;
    return;
  }
  file_writer_delegate_->Start(file.ReleaseValue(), blob_request_.get());
}

bool FileSystemOperation::VerifyFileSystemPathForRead(
    const GURL& path, GURL* origin_url, FileSystemType* type,
    FilePath* virtual_path, FileSystemFileUtil** file_util) {
  if (!VerifyFileSystemPath(path, origin_url, type, virtual_path, file_util))
    return false;

  // We notify this read access whether the read access succeeds or not.
  // This must be ok since this is used to let the QM's eviction logic know
  // someone is interested in reading the origin data and therefore to indicate
  // that evicting this origin may not be a good idea.
  FileSystemQuotaUtil* quota_util = file_system_context()->GetQuotaUtil(*type);
  if (quota_util) {
    quota_util->NotifyOriginWasAccessedOnIOThread(
        file_system_context()->quota_manager_proxy(),
        *origin_url,
        *type);
  }

  return true;
}

bool FileSystemOperation::VerifyFileSystemPathForWrite(
    const GURL& path, bool create, GURL* origin_url, FileSystemType* type,
    FilePath* virtual_path, FileSystemFileUtil** file_util) {
  if (!VerifyFileSystemPath(path, origin_url, type, virtual_path, file_util))
    return false;

  // Any write access is disallowed on the root path.
  if (virtual_path->value().length() == 0 ||
      virtual_path->DirName().value() == virtual_path->value()) {
    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
    return false;
  }
  if (create && file_system_context()->path_manager()->IsRestrictedFileName(
          *type, virtual_path->BaseName())) {
    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
    return false;
  }

  return true;
}

bool FileSystemOperation::VerifyFileSystemPath(
    const GURL& path, GURL* origin_url, FileSystemType* type,
    FilePath* virtual_path, FileSystemFileUtil** file_util) {
  DCHECK(file_system_context());

  if (!CrackFileSystemURL(path, origin_url, type, virtual_path)) {
    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_INVALID_URL);
    return false;
  }
  if (!file_system_context()->path_manager()->IsAccessAllowed(
      *origin_url, *type, *virtual_path)) {
    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
    return false;
  }
  DCHECK(file_util);
  *file_util = file_system_context()->path_manager()->GetFileUtil(*type);
  DCHECK(*file_util);

  return true;
}

bool FileSystemOperation::SetupSrcContextForRead(const GURL& path) {
  GURL origin_url;
  FileSystemType type;
  FileSystemFileUtil* file_util;
  bool result = VerifyFileSystemPathForRead(
      path, &origin_url, &type, &src_virtual_path_, &file_util);
  operation_context_.set_src_origin_url(origin_url);
  operation_context_.set_src_type(type);
  if (!operation_context_.src_file_util())
    operation_context_.set_src_file_util(file_util);
  return result;
}

bool FileSystemOperation::SetupSrcContextForWrite(const GURL& path,
                                                  bool create) {
  GURL origin_url;
  FileSystemType type;
  FileSystemFileUtil* file_util;
  bool result = VerifyFileSystemPathForWrite(
      path, create, &origin_url, &type, &src_virtual_path_, &file_util);
  operation_context_.set_src_origin_url(origin_url);
  operation_context_.set_src_type(type);
  if (!operation_context_.src_file_util())
    operation_context_.set_src_file_util(file_util);
  return result;
}

bool FileSystemOperation::SetupDestContextForWrite(const GURL& path,
                                                   bool create) {
  GURL origin_url;
  FileSystemType type;
  FileSystemFileUtil* file_util;
  bool result = VerifyFileSystemPathForWrite(
      path, create, &origin_url, &type, &dest_virtual_path_, &file_util);
  operation_context_.set_dest_origin_url(origin_url);
  operation_context_.set_dest_type(type);
  if (!operation_context_.dest_file_util())
    operation_context_.set_dest_file_util(file_util);
  return result;
}

}  // namespace fileapi