chrome/browser/chromeos/drive/file_system/copy_operation.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_COPY_OPERATION_H_
   6 #define CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_COPY_OPERATION_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "chrome/browser/chromeos/drive/file_errors.h"
  16 #include "google_apis/drive/drive_api_error_codes.h"
  17
  18 namespace base {
  19 class FilePath;
  20 class SequencedTaskRunner;
  21 class Time;
  22 }  // namespace base
  23
  24 namespace google_apis {
  25 class FileResource;
  26 }  // namespace google_apis
  27
  28 namespace drive {
  29
  30 class JobScheduler;
  31 class ResourceEntry;
  32
  33 namespace internal {
  34 class FileCache;
  35 class ResourceMetadata;
  36 }  // namespace internal
  37
  38 namespace file_system {
  39
  40 class CreateFileOperation;
  41 class OperationDelegate;
  42
  43 // This class encapsulates the drive Copy function.  It is responsible for
  44 // sending the request to the drive API, then updating the local state and
  45 // metadata to reflect the new state.
  46 class CopyOperation {
  47  public:
  48   CopyOperation(base::SequencedTaskRunner* blocking_task_runner,
  49                 OperationDelegate* delegate,
  50                 JobScheduler* scheduler,
  51                 internal::ResourceMetadata* metadata,
  52                 internal::FileCache* cache);
  53   ~CopyOperation();
  54
  55   // Performs the copy operation on the file at drive path |src_file_path|
  56   // with a target of |dest_file_path|.
  57   // If |preserve_last_modified| is set to true, this tries to preserve
  58   // last modified time stamp. This is supported only on Drive API v2.
  59   // Invokes |callback| when finished with the result of the operation.
  60   // |callback| must not be null.
  61   void Copy(const base::FilePath& src_file_path,
  62             const base::FilePath& dest_file_path,
  63             bool preserve_last_modified,
  64             const FileOperationCallback& callback);
  65
  66   // Initiates transfer of |local_src_file_path| to |remote_dest_file_path|.
  67   // |local_src_file_path| must be a file from the local file system.
  68   // |remote_dest_file_path| is the virtual destination path within Drive file
  69   // system.
  70   //
  71   // |callback| must not be null.
  72   void TransferFileFromLocalToRemote(
  73       const base::FilePath& local_src_file_path,
  74       const base::FilePath& remote_dest_file_path,
  75       const FileOperationCallback& callback);
  76
  77   // Params for Copy().
  78   struct CopyParams;
  79
  80   // Params for TransferJsonGdocFileAfterLocalWork.
  81   struct TransferJsonGdocParams;
  82
  83  private:
  84   // Part of Copy(). Called after trying to copy locally.
  85   void CopyAfterTryToCopyLocally(
  86       const CopyParams* params,
  87       const std::vector<std::string>* updated_local_ids,
  88       const bool* directory_changed,
  89       const bool* should_copy_on_server,
  90       FileError error);
  91
  92   // Part of Copy(). Called after the parent entry gets synced.
  93   void CopyAfterParentSync(const CopyParams& params, FileError error);
  94
  95   // Part of Copy(). Called after the parent resource ID is resolved.
  96   void CopyAfterGetParentResourceId(const CopyParams& params,
  97                                     const ResourceEntry* parent,
  98                                     FileError error);
  99
 100   // Part of TransferFileFromLocalToRemote(). Called after preparation is done.
 101   // |gdoc_resource_id| and |parent_resource_id| is available only if the file
 102   // is JSON GDoc file.
 103   void TransferFileFromLocalToRemoteAfterPrepare(
 104       const base::FilePath& local_src_path,
 105       const base::FilePath& remote_dest_path,
 106       const FileOperationCallback& callback,
 107       std::string* gdoc_resource_id,
 108       ResourceEntry* parent_entry,
 109       FileError error);
 110
 111   // Part of TransferFileFromLocalToRemote().
 112   void TransferJsonGdocFileAfterLocalWork(TransferJsonGdocParams* params,
 113                                           FileError error);
 114
 115   // Copies resource with |resource_id| into the directory |parent_resource_id|
 116   // with renaming it to |new_title|.
 117   void CopyResourceOnServer(const std::string& resource_id,
 118                             const std::string& parent_resource_id,
 119                             const std::string& new_title,
 120                             const base::Time& last_modified,
 121                             const FileOperationCallback& callback);
 122
 123   // Part of CopyResourceOnServer and TransferFileFromLocalToRemote.
 124   // Called after server side operation is done.
 125   void UpdateAfterServerSideOperation(
 126       const FileOperationCallback& callback,
 127       google_apis::DriveApiErrorCode status,
 128       scoped_ptr<google_apis::FileResource> entry);
 129
 130   // Part of CopyResourceOnServer and TransferFileFromLocalToRemote.
 131   // Called after local state update is done.
 132   void UpdateAfterLocalStateUpdate(const FileOperationCallback& callback,
 133                                    base::FilePath* file_path,
 134                                    const ResourceEntry* entry,
 135                                    FileError error);
 136
 137   // Creates an empty file on the server at |remote_dest_path| to ensure
 138   // the location, stores a file at |local_file_path| in cache and marks it
 139   // dirty, so that SyncClient will upload the data later.
 140   void ScheduleTransferRegularFile(const base::FilePath& local_src_path,
 141                                    const base::FilePath& remote_dest_path,
 142                                    const FileOperationCallback& callback);
 143
 144   // Part of ScheduleTransferRegularFile(). Called after file creation.
 145   void ScheduleTransferRegularFileAfterCreate(
 146       const base::FilePath& local_src_path,
 147       const base::FilePath& remote_dest_path,
 148       const FileOperationCallback& callback,
 149       FileError error);
 150
 151   // Part of ScheduleTransferRegularFile(). Called after updating local state
 152   // is completed.
 153   void ScheduleTransferRegularFileAfterUpdateLocalState(
 154       const FileOperationCallback& callback,
 155       const base::FilePath& remote_dest_path,
 156       const ResourceEntry* entry,
 157       std::string* local_id,
 158       FileError error);
 159
 160   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 161   OperationDelegate* delegate_;
 162   JobScheduler* scheduler_;
 163   internal::ResourceMetadata* metadata_;
 164   internal::FileCache* cache_;
 165
 166   // Uploading a new file is internally implemented by creating a dirty file.
 167   scoped_ptr<CreateFileOperation> create_file_operation_;
 168
 169   // Note: This should remain the last member so it'll be destroyed and
 170   // invalidate the weak pointers before any other members are destroyed.
 171   base::WeakPtrFactory<CopyOperation> weak_ptr_factory_;
 172   DISALLOW_COPY_AND_ASSIGN(CopyOperation);
 173 };
 174
 175 }  // namespace file_system
 176 }  // namespace drive
 177
 178 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_COPY_OPERATION_H_