chrome/browser/chromeos/file_system_provider/provided_file_system.cc

// Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/provided_file_system.h"

#include <vector>

#include "base/debug/trace_event.h"
#include "base/files/file.h"
#include "chrome/browser/chromeos/file_system_provider/notification_manager.h"
#include "chrome/browser/chromeos/file_system_provider/operations/abort.h"
#include "chrome/browser/chromeos/file_system_provider/operations/close_file.h"
#include "chrome/browser/chromeos/file_system_provider/operations/copy_entry.h"
#include "chrome/browser/chromeos/file_system_provider/operations/create_directory.h"
#include "chrome/browser/chromeos/file_system_provider/operations/create_file.h"
#include "chrome/browser/chromeos/file_system_provider/operations/delete_entry.h"
#include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
#include "chrome/browser/chromeos/file_system_provider/operations/move_entry.h"
#include "chrome/browser/chromeos/file_system_provider/operations/observe_directory.h"
#include "chrome/browser/chromeos/file_system_provider/operations/open_file.h"
#include "chrome/browser/chromeos/file_system_provider/operations/read_directory.h"
#include "chrome/browser/chromeos/file_system_provider/operations/read_file.h"
#include "chrome/browser/chromeos/file_system_provider/operations/truncate.h"
#include "chrome/browser/chromeos/file_system_provider/operations/unmount.h"
#include "chrome/browser/chromeos/file_system_provider/operations/unobserve_entry.h"
#include "chrome/browser/chromeos/file_system_provider/operations/write_file.h"
#include "chrome/browser/chromeos/file_system_provider/request_manager.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/extensions/api/file_system_provider.h"
#include "extensions/browser/event_router.h"

namespace net {
class IOBuffer;
}  // namespace net

namespace chromeos {
namespace file_system_provider {
namespace {

// Discards the result of Abort() when called from the destructor.
void EmptyStatusCallback(base::File::Error /* result */) {
}

}  // namespace

AutoUpdater::AutoUpdater(const base::Closure& update_callback)
    : update_callback_(update_callback),
      created_callbacks_(0),
      pending_callbacks_(0) {
}

base::Closure AutoUpdater::CreateCallback() {
  ++created_callbacks_;
  ++pending_callbacks_;
  return base::Bind(&AutoUpdater::OnPendingCallback, this);
}

void AutoUpdater::OnPendingCallback() {
  DCHECK_LT(0, pending_callbacks_);
  if (--pending_callbacks_ == 0)
    update_callback_.Run();
}

AutoUpdater::~AutoUpdater() {
  // If no callbacks are created, then we need to invoke updating in the
  // destructor.
  if (!created_callbacks_)
    update_callback_.Run();
  else if (pending_callbacks_)
    LOG(ERROR) << "Not all callbacks called. This may happen on shutdown.";
}

ProvidedFileSystem::ProvidedFileSystem(
    Profile* profile,
    const ProvidedFileSystemInfo& file_system_info)
    : profile_(profile),
      event_router_(extensions::EventRouter::Get(profile)),  // May be NULL.
      file_system_info_(file_system_info),
      notification_manager_(
          new NotificationManager(profile_, file_system_info_)),
      request_manager_(new RequestManager(notification_manager_.get())),
      weak_ptr_factory_(this) {
}

ProvidedFileSystem::~ProvidedFileSystem() {
  const std::vector<int> request_ids = request_manager_->GetActiveRequestIds();
  for (size_t i = 0; i < request_ids.size(); ++i) {
    Abort(request_ids[i], base::Bind(&EmptyStatusCallback));
  }
}

void ProvidedFileSystem::SetEventRouterForTesting(
    extensions::EventRouter* event_router) {
  event_router_ = event_router;
}

void ProvidedFileSystem::SetNotificationManagerForTesting(
    scoped_ptr<NotificationManagerInterface> notification_manager) {
  notification_manager_ = notification_manager.Pass();
  request_manager_.reset(new RequestManager(notification_manager_.get()));
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::RequestUnmount(
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      REQUEST_UNMOUNT,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::Unmount(event_router_, file_system_info_, callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::GetMetadata(
    const base::FilePath& entry_path,
    MetadataFieldMask fields,
    const GetMetadataCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      GET_METADATA,
      scoped_ptr<RequestManager::HandlerInterface>(new operations::GetMetadata(
          event_router_, file_system_info_, entry_path, fields, callback)));
  if (!request_id) {
    callback.Run(make_scoped_ptr<EntryMetadata>(NULL),
                 base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::ReadDirectory(
    const base::FilePath& directory_path,
    const storage::AsyncFileUtil::ReadDirectoryCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      READ_DIRECTORY,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::ReadDirectory(
              event_router_, file_system_info_, directory_path, callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY,
                 storage::AsyncFileUtil::EntryList(),
                 false /* has_more */);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::ReadFile(
    int file_handle,
    net::IOBuffer* buffer,
    int64 offset,
    int length,
    const ReadChunkReceivedCallback& callback) {
  TRACE_EVENT1(
      "file_system_provider", "ProvidedFileSystem::ReadFile", "length", length);
  const int request_id = request_manager_->CreateRequest(
      READ_FILE,
      make_scoped_ptr<RequestManager::HandlerInterface>(
          new operations::ReadFile(event_router_,
                                   file_system_info_,
                                   file_handle,
                                   buffer,
                                   offset,
                                   length,
                                   callback)));
  if (!request_id) {
    callback.Run(0 /* chunk_length */,
                 false /* has_more */,
                 base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::OpenFile(
    const base::FilePath& file_path,
    OpenFileMode mode,
    const OpenFileCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      OPEN_FILE,
      scoped_ptr<RequestManager::HandlerInterface>(new operations::OpenFile(
          event_router_, file_system_info_, file_path, mode, callback)));
  if (!request_id) {
    callback.Run(0 /* file_handle */, base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::CloseFile(
    int file_handle,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      CLOSE_FILE,
      scoped_ptr<RequestManager::HandlerInterface>(new operations::CloseFile(
          event_router_, file_system_info_, file_handle, callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::CreateDirectory(
    const base::FilePath& directory_path,
    bool recursive,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      CREATE_DIRECTORY,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::CreateDirectory(event_router_,
                                          file_system_info_,
                                          directory_path,
                                          recursive,
                                          callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::DeleteEntry(
    const base::FilePath& entry_path,
    bool recursive,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      DELETE_ENTRY,
      scoped_ptr<RequestManager::HandlerInterface>(new operations::DeleteEntry(
          event_router_, file_system_info_, entry_path, recursive, callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::CreateFile(
    const base::FilePath& file_path,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      CREATE_FILE,
      scoped_ptr<RequestManager::HandlerInterface>(new operations::CreateFile(
          event_router_, file_system_info_, file_path, callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::CopyEntry(
    const base::FilePath& source_path,
    const base::FilePath& target_path,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      COPY_ENTRY,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::CopyEntry(event_router_,
                                    file_system_info_,
                                    source_path,
                                    target_path,
                                    callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::WriteFile(
    int file_handle,
    net::IOBuffer* buffer,
    int64 offset,
    int length,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  TRACE_EVENT1("file_system_provider",
               "ProvidedFileSystem::WriteFile",
               "length",
               length);
  const int request_id = request_manager_->CreateRequest(
      WRITE_FILE,
      make_scoped_ptr<RequestManager::HandlerInterface>(
          new operations::WriteFile(event_router_,
                                    file_system_info_,
                                    file_handle,
                                    make_scoped_refptr(buffer),
                                    offset,
                                    length,
                                    callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::MoveEntry(
    const base::FilePath& source_path,
    const base::FilePath& target_path,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      MOVE_ENTRY,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::MoveEntry(event_router_,
                                    file_system_info_,
                                    source_path,
                                    target_path,
                                    callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::Truncate(
    const base::FilePath& file_path,
    int64 length,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const int request_id = request_manager_->CreateRequest(
      TRUNCATE,
      scoped_ptr<RequestManager::HandlerInterface>(new operations::Truncate(
          event_router_, file_system_info_, file_path, length, callback)));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

ProvidedFileSystem::AbortCallback ProvidedFileSystem::ObserveDirectory(
    const base::FilePath& directory_path,
    bool recursive,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  // TODO(mtomasz): Wrap the entire method body with an asynchronous queue to
  // avoid races.
  const ObservedEntries::const_iterator it =
      observed_entries_.find(directory_path);
  if (it != observed_entries_.end()) {
    if (!recursive || it->second.recursive) {
      callback.Run(base::File::FILE_ERROR_EXISTS);
      return AbortCallback();
    }
  }

  const int request_id = request_manager_->CreateRequest(
      OBSERVE_DIRECTORY,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::ObserveDirectory(
              event_router_,
              file_system_info_,
              directory_path,
              recursive,
              base::Bind(&ProvidedFileSystem::OnObserveDirectoryCompleted,
                         weak_ptr_factory_.GetWeakPtr(),
                         directory_path,
                         recursive,
                         callback))));
  if (!request_id) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
    return AbortCallback();
  }

  return base::Bind(
      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
}

void ProvidedFileSystem::UnobserveEntry(
    const base::FilePath& entry_path,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  const ObservedEntries::const_iterator it = observed_entries_.find(entry_path);
  if (it == observed_entries_.end()) {
    callback.Run(base::File::FILE_ERROR_NOT_FOUND);
    return;
  }

  // Delete the watcher in advance since the list of observed entries is owned
  // by the C++ layer, not by the extension.
  observed_entries_.erase(it);

  FOR_EACH_OBSERVER(
      ProvidedFileSystemObserver,
      observers_,
      OnObservedEntryListChanged(file_system_info_, observed_entries_));

  // TODO(mtomasz): Consider returning always an OK error code, since for the
  // callers it's important that the entry is not watched anymore. The watcher
  // is removed even if the extension returns an error.
  const int request_id = request_manager_->CreateRequest(
      UNOBSERVE_ENTRY,
      scoped_ptr<RequestManager::HandlerInterface>(
          new operations::UnobserveEntry(
              event_router_, file_system_info_, entry_path, callback)));
  if (!request_id)
    callback.Run(base::File::FILE_ERROR_SECURITY);
}

const ProvidedFileSystemInfo& ProvidedFileSystem::GetFileSystemInfo() const {
  return file_system_info_;
}

RequestManager* ProvidedFileSystem::GetRequestManager() {
  return request_manager_.get();
}

ObservedEntries* ProvidedFileSystem::GetObservedEntries() {
  return &observed_entries_;
}

void ProvidedFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
  DCHECK(observer);
  observers_.AddObserver(observer);
}

void ProvidedFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

bool ProvidedFileSystem::Notify(
    const base::FilePath& observed_path,
    ProvidedFileSystemObserver::ChangeType change_type,
    scoped_ptr<ProvidedFileSystemObserver::ChildChanges> child_changes,
    const std::string& tag) {
  const ObservedEntries::iterator it = observed_entries_.find(observed_path);
  if (it == observed_entries_.end())
    return false;

  // The tag must be provided if and only if it's explicitly supported.
  if (file_system_info_.supports_notify_tag() == tag.empty())
    return false;

  // The object is owned by AutoUpdated, so the reference is valid as long as
  // callbacks created with AutoUpdater::CreateCallback().
  const ProvidedFileSystemObserver::ChildChanges& child_changes_ref =
      *child_changes.get();

  scoped_refptr<AutoUpdater> auto_updater(
      new AutoUpdater(base::Bind(&ProvidedFileSystem::OnNotifyCompleted,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 observed_path,
                                 change_type,
                                 base::Passed(&child_changes),
                                 it->second.last_tag,
                                 tag)));

  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                    observers_,
                    OnObservedEntryChanged(file_system_info_,
                                           it->second,
                                           change_type,
                                           child_changes_ref,
                                           auto_updater->CreateCallback()));

  return true;
}

base::WeakPtr<ProvidedFileSystemInterface> ProvidedFileSystem::GetWeakPtr() {
  return weak_ptr_factory_.GetWeakPtr();
}

void ProvidedFileSystem::Abort(
    int operation_request_id,
    const storage::AsyncFileUtil::StatusCallback& callback) {
  request_manager_->RejectRequest(operation_request_id,
                                  make_scoped_ptr(new RequestValue()),
                                  base::File::FILE_ERROR_ABORT);
  if (!request_manager_->CreateRequest(
          ABORT,
          scoped_ptr<RequestManager::HandlerInterface>(
              new operations::Abort(event_router_,
                                    file_system_info_,
                                    operation_request_id,
                                    callback)))) {
    callback.Run(base::File::FILE_ERROR_SECURITY);
  }
}

void ProvidedFileSystem::OnObserveDirectoryCompleted(
    const base::FilePath& directory_path,
    bool recursive,
    const storage::AsyncFileUtil::StatusCallback& callback,
    base::File::Error result) {
  if (result != base::File::FILE_OK) {
    callback.Run(result);
    return;
  }

  observed_entries_[directory_path].entry_path = directory_path;
  observed_entries_[directory_path].recursive |= recursive;

  FOR_EACH_OBSERVER(
      ProvidedFileSystemObserver,
      observers_,
      OnObservedEntryListChanged(file_system_info_, observed_entries_));

  callback.Run(result);
}

void ProvidedFileSystem::OnNotifyCompleted(
    const base::FilePath& observed_path,
    ProvidedFileSystemObserver::ChangeType change_type,
    scoped_ptr<ProvidedFileSystemObserver::ChildChanges> /* child_changes */,
    const std::string& last_tag,
    const std::string& tag) {
  const ObservedEntries::iterator it = observed_entries_.find(observed_path);
  // Check if the entry is still observed.
  if (it == observed_entries_.end())
    return;

  // Another following notification finished earlier.
  if (it->second.last_tag != last_tag)
    return;

  // It's illegal to provide a tag which is not unique. As for now only an error
  // message is printed, but we may want to pass the error to the providing
  // extension. TODO(mtomasz): Consider it.
  if (!tag.empty() && tag == it->second.last_tag)
    LOG(ERROR) << "Tag specified, but same as the previous one.";

  it->second.last_tag = tag;

  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                    observers_,
                    OnObservedEntryTagUpdated(file_system_info_, it->second));

  // If the observed entry is deleted, then unobserve it.
  if (change_type == ProvidedFileSystemObserver::DELETED)
    UnobserveEntry(observed_path, base::Bind(&EmptyStatusCallback));
}

}  // namespace file_system_provider
}  // namespace chromeos