chrome/browser/ash/drive/fileapi/drivefs_async_file_util.cc

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ash/drive/fileapi/drivefs_async_file_util.h"

#include <utility>

#include "ash/constants/ash_features.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_refptr.h"
#include "base/task/sequenced_task_runner.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "components/drive/file_errors.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "mojo/public/cpp/bindings/callback_helpers.h"
#include "storage/browser/file_system/file_system_context.h"
#include "storage/browser/file_system/file_system_operation.h"
#include "storage/browser/file_system/file_system_operation_context.h"
#include "storage/browser/file_system/file_system_url.h"
#include "storage/browser/file_system/local_file_util.h"
#include "storage/browser/file_system/native_file_util.h"
#include "storage/common/file_system/file_system_util.h"

namespace drive::internal {
namespace {

class DriveFsFileUtil : public storage::LocalFileUtil {
 public:
  DriveFsFileUtil() = default;

  DriveFsFileUtil(const DriveFsFileUtil&) = delete;
  DriveFsFileUtil& operator=(const DriveFsFileUtil&) = delete;

  ~DriveFsFileUtil() override = default;

 protected:
  bool IsHiddenItem(const base::FilePath& local_file_path) const override {
    // DriveFS is a trusted filesystem, allow symlinks.
    return false;
  }
};

class CopyOperation : public base::RefCountedThreadSafe<CopyOperation> {
 public:
  CopyOperation(
      Profile* const profile,
      std::unique_ptr<storage::FileSystemOperationContext> context,
      storage::FileSystemURL src_url,
      storage::FileSystemURL dest_url,
      storage::AsyncFileUtil::CopyOrMoveOptionSet options,
      storage::AsyncFileUtil::CopyFileProgressCallback progress_callback,
      storage::AsyncFileUtil::StatusCallback callback,
      scoped_refptr<base::SequencedTaskRunner> origin_task_runner,
      base::WeakPtr<DriveFsAsyncFileUtil> async_file_util)
      : profile_(profile),
        context_(std::move(context)),
        src_url_(std::move(src_url)),
        dest_url_(std::move(dest_url)),
        options_(std::move(options)),
        progress_callback_(std::move(progress_callback)),
        callback_(std::move(callback)),
        origin_task_runner_(std::move(origin_task_runner)),
        async_file_util_(std::move(async_file_util)) {
    DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
  }

  void Start() {
    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

    auto* drive_integration_service =
        drive::util::GetIntegrationServiceByProfile(profile_);
    base::FilePath source_path("/");
    base::FilePath destination_path("/");
    if (!drive_integration_service ||
        !drive_integration_service->GetMountPointPath().AppendRelativePath(
            src_url_.path(), &source_path) ||
        !drive_integration_service->GetMountPointPath().AppendRelativePath(
            dest_url_.path(), &destination_path)) {
      origin_task_runner_->PostTask(
          FROM_HERE, base::BindOnce(std::move(callback_),
                                    base::File::FILE_ERROR_INVALID_OPERATION));
      return;
    }
    drive_integration_service->GetDriveFsInterface()->CopyFile(
        source_path, destination_path,
        mojo::WrapCallbackWithDefaultInvokeIfNotRun(
            base::BindOnce(&CopyOperation::CopyComplete, this),
            drive::FILE_ERROR_ABORT));
  }

 private:
  friend class base::RefCountedThreadSafe<CopyOperation>;
  ~CopyOperation() = default;

  void CopyComplete(drive::FileError error) {
    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

    switch (error) {
      case drive::FILE_ERROR_NOT_FOUND:
      case drive::FILE_ERROR_NO_CONNECTION:
        origin_task_runner_->PostTask(
            FROM_HERE,
            base::BindOnce(&CopyOperation::FallbackToNativeCopyOnOriginThread,
                           this));
        break;

      default:
        origin_task_runner_->PostTask(
            FROM_HERE, base::BindOnce(std::move(callback_),
                                      FileErrorToBaseFileError(error)));
    }
  }

  void FallbackToNativeCopyOnOriginThread() {
    DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());

    if (!async_file_util_) {
      std::move(callback_).Run(base::File::FILE_ERROR_ABORT);
      return;
    }
    async_file_util_->AsyncFileUtilAdapter::CopyFileLocal(
        std::move(context_), src_url_, dest_url_, options_,
        std::move(progress_callback_), std::move(callback_));
  }

  const raw_ptr<Profile> profile_;
  std::unique_ptr<storage::FileSystemOperationContext> context_;
  const storage::FileSystemURL src_url_;
  const storage::FileSystemURL dest_url_;
  const storage::AsyncFileUtil::CopyOrMoveOptionSet options_;
  storage::AsyncFileUtil::CopyFileProgressCallback progress_callback_;
  storage::AsyncFileUtil::StatusCallback callback_;
  const scoped_refptr<base::SequencedTaskRunner> origin_task_runner_;
  const base::WeakPtr<DriveFsAsyncFileUtil> async_file_util_;
};

// Recursively deletes a folder locally. The folder will still be available in
// Drive cloud Trash.
class DeleteOperation : public base::RefCountedThreadSafe<DeleteOperation> {
 public:
  using PinningManager = drivefs::pinning::PinningManager;
  using Id = PinningManager::Id;

  DeleteOperation(Profile* const profile,
                  base::FilePath path,
                  storage::AsyncFileUtil::StatusCallback callback,
                  scoped_refptr<base::SequencedTaskRunner> origin_task_runner,
                  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
      : profile_(profile),
        path_(std::move(path)),
        callback_(std::move(callback)),
        origin_task_runner_(std::move(origin_task_runner)),
        blocking_task_runner_(std::move(blocking_task_runner)) {
    DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
  }

  void Start() {
    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

    DCHECK(!drive_);
    drive_ = drive::util::GetIntegrationServiceByProfile(profile_);
    base::FilePath relative_path;
    if (!drive_ || !drive_->GetMountPointPath().IsParent(path_)) {
      origin_task_runner_->PostTask(
          FROM_HERE,
          base::BindOnce(std::move(callback_), base::File::FILE_ERROR_FAILED));
      return;
    }

    if (drive_->GetPinningManager() &&
        drive_->GetRelativeDrivePath(path_, &drive_path_)) {
      // TODO(b/266168982): In the case this is a folder, only the folder will
      // get unpinned leaving all the children pinned. When the new method is
      // exposed (or parameter on the existing method) update the
      // implementation here.
      drive_->GetDriveFsInterface()->GetMetadata(
          drive_path_, base::BindOnce(&DeleteOperation::OnGotMetadata, this));
      return;
    }

    blocking_task_runner_->PostTask(
        FROM_HERE, base::BindOnce(&DeleteOperation::Delete, this));
  }

 private:
  friend class base::RefCountedThreadSafe<DeleteOperation>;
  ~DeleteOperation() = default;

  void OnGotMetadata(const drive::FileError error,
                     const drivefs::mojom::FileMetadataPtr metadata) {
    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

    if (error != drive::FILE_ERROR_OK) {
      LOG(ERROR) << "Cannot get metadata of '" << drive_path_ << "': " << error;
    } else {
      DCHECK(metadata);
      id_ = Id(metadata->stable_id);
    }

    blocking_task_runner_->PostTask(
        FROM_HERE, base::BindOnce(&DeleteOperation::Delete, this));
  }

  void Delete() {
    VLOG(1) << "Deleting '" << path_ << "'...";
    const bool deleted = base::DeletePathRecursively(path_);

    if (deleted) {
      VLOG(1) << "Deleted '" << path_ << "'";
      content::GetUIThreadTaskRunner({})->PostTask(
          FROM_HERE, base::BindOnce(&DeleteOperation::OnDeleted, this));
    } else {
      LOG(ERROR) << "Cannot delete '" << path_ << "'";
    }

    origin_task_runner_->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback_),
                                  deleted ? base::File::FILE_OK
                                          : base::File::FILE_ERROR_FAILED));
  }

  void OnDeleted() {
    DCHECK(drive_);
    if (PinningManager* const pinning_manager = drive_->GetPinningManager()) {
      // TODO(b/267225898) Local delete events are currently not sent via
      // DriveFS, so for now we notify the `PinningManager` for local deletes.
      pinning_manager->NotifyDelete(id_, drive_path_);
    }
  }

  const raw_ptr<Profile> profile_;
  const base::FilePath path_;
  base::FilePath drive_path_;
  Id id_ = Id::kNone;
  storage::AsyncFileUtil::StatusCallback callback_;
  const scoped_refptr<base::SequencedTaskRunner> origin_task_runner_;
  const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;

  raw_ptr<drive::DriveIntegrationService> drive_ = nullptr;
};

}  // namespace

DriveFsAsyncFileUtil::DriveFsAsyncFileUtil(Profile* profile)
    : AsyncFileUtilAdapter(std::make_unique<DriveFsFileUtil>()),
      profile_(profile) {}

DriveFsAsyncFileUtil::~DriveFsAsyncFileUtil() = default;

void DriveFsAsyncFileUtil::CopyFileLocal(
    std::unique_ptr<storage::FileSystemOperationContext> context,
    const storage::FileSystemURL& src_url,
    const storage::FileSystemURL& dest_url,
    CopyOrMoveOptionSet options,
    CopyFileProgressCallback progress_callback,
    StatusCallback callback) {
  content::GetUIThreadTaskRunner({})->PostTask(
      FROM_HERE,
      base::BindOnce(&CopyOperation::Start,
                     base::MakeRefCounted<CopyOperation>(
                         profile_, std::move(context), src_url, dest_url,
                         std::move(options), std::move(progress_callback),
                         std::move(callback),
                         base::SequencedTaskRunner::GetCurrentDefault(),
                         weak_factory_.GetWeakPtr())));
}

void DriveFsAsyncFileUtil::DeleteRecursively(
    std::unique_ptr<storage::FileSystemOperationContext> context,
    const storage::FileSystemURL& url,
    StatusCallback callback) {
  content::GetUIThreadTaskRunner({})->PostTask(
      FROM_HERE,
      base::BindOnce(&DeleteOperation::Start,
                     base::MakeRefCounted<DeleteOperation>(
                         profile_, url.path(), std::move(callback),
                         base::SequencedTaskRunner::GetCurrentDefault(),
                         context->task_runner())));
}

}  // namespace drive::internal