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 "base/basictypes.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "chrome/browser/chromeos/drive/file_errors.h"
  13 #include "chrome/browser/drive/drive_service_interface.h"
  14 #include "google_apis/drive/gdata_errorcode.h"
  15
  16 namespace base {
  17 class FilePath;
  18 class SequencedTaskRunner;
  19 class Time;
  20 }  // namespace base
  21
  22 namespace google_apis {
  23 class AboutResource;
  24 class ResourceEntry;
  25 }  // namespace google_apis
  26
  27 namespace drive {
  28
  29 class JobScheduler;
  30 class ResourceEntry;
  31
  32 namespace internal {
  33 class FileCache;
  34 class ResourceMetadata;
  35 }  // namespace internal
  36
  37 namespace file_system {
  38
  39 class CreateFileOperation;
  40 class OperationObserver;
  41
  42 // This class encapsulates the drive Copy function.  It is responsible for
  43 // sending the request to the drive API, then updating the local state and
  44 // metadata to reflect the new state.
  45 class CopyOperation {
  46  public:
  47   CopyOperation(base::SequencedTaskRunner* blocking_task_runner,
  48                 OperationObserver* observer,
  49                 JobScheduler* scheduler,
  50                 internal::ResourceMetadata* metadata,
  51                 internal::FileCache* cache,
  52                 const ResourceIdCanonicalizer& id_canonicalizer);
  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  private:
  78   // Params for Copy().
  79   struct CopyParams;
  80
  81   // Part of Copy(). Called after prepartion is done.
  82   void CopyAfterPrepare(const CopyParams& params,
  83                         ResourceEntry* src_entry,
  84                         std::string* parent_resource_id,
  85                         FileError error);
  86
  87   // Part of TransferFileFromLocalToRemote(). Called after preparation is done.
  88   // |gdoc_resource_id| and |parent_resource_id| is available only if the file
  89   // is JSON GDoc file.
  90   void TransferFileFromLocalToRemoteAfterPrepare(
  91       const base::FilePath& local_src_path,
  92       const base::FilePath& remote_dest_path,
  93       const FileOperationCallback& callback,
  94       std::string* gdoc_resource_id,
  95       std::string* parent_resource_id,
  96       FileError error);
  97
  98   // Copies resource with |resource_id| into the directory |parent_resource_id|
  99   // with renaming it to |new_title|.
 100   void CopyResourceOnServer(const std::string& resource_id,
 101                             const std::string& parent_resource_id,
 102                             const std::string& new_title,
 103                             const base::Time& last_modified,
 104                             const FileOperationCallback& callback);
 105
 106   // Part of CopyResourceOnServer. Called after server side copy is done.
 107   void CopyResourceOnServerAfterServerSideCopy(
 108       const FileOperationCallback& callback,
 109       google_apis::GDataErrorCode status,
 110       scoped_ptr<google_apis::ResourceEntry> resource_entry);
 111
 112   // Part of CopyResourceOnServer. Called after local state update is done.
 113   void CopyResourceOnServerAfterUpdateLocalState(
 114       const FileOperationCallback& callback,
 115       base::FilePath* file_path,
 116       FileError error);
 117
 118   // Creates an empty file on the server at |remote_dest_path| to ensure
 119   // the location, stores a file at |local_file_path| in cache and marks it
 120   // dirty, so that SyncClient will upload the data later.
 121   void ScheduleTransferRegularFile(const base::FilePath& local_src_path,
 122                                    const base::FilePath& remote_dest_path,
 123                                    const FileOperationCallback& callback);
 124
 125   // Part of ScheduleTransferRegularFile(). Called after GetFileSize() is
 126   // completed.
 127   void ScheduleTransferRegularFileAfterGetFileSize(
 128       const base::FilePath& local_src_path,
 129       const base::FilePath& remote_dest_path,
 130       const FileOperationCallback& callback,
 131       int64 local_file_size);
 132
 133   // Part of ScheduleTransferRegularFile(). Called after GetAboutResource()
 134   // is completed.
 135   void ScheduleTransferRegularFileAfterGetAboutResource(
 136       const base::FilePath& local_src_path,
 137       const base::FilePath& remote_dest_path,
 138       const FileOperationCallback& callback,
 139       int64 local_file_size,
 140       google_apis::GDataErrorCode status,
 141       scoped_ptr<google_apis::AboutResource> about_resource);
 142
 143   // Part of ScheduleTransferRegularFile(). Called after file creation.
 144   void ScheduleTransferRegularFileAfterCreate(
 145       const base::FilePath& local_src_path,
 146       const base::FilePath& remote_dest_path,
 147       const FileOperationCallback& callback,
 148       FileError error);
 149
 150   // Part of ScheduleTransferRegularFile(). Called after updating local state
 151   // is completed.
 152   void ScheduleTransferRegularFileAfterUpdateLocalState(
 153       const FileOperationCallback& callback,
 154       std::string* local_id,
 155       FileError error);
 156
 157   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 158   OperationObserver* observer_;
 159   JobScheduler* scheduler_;
 160   internal::ResourceMetadata* metadata_;
 161   internal::FileCache* cache_;
 162   ResourceIdCanonicalizer id_canonicalizer_;
 163
 164   // Uploading a new file is internally implemented by creating a dirty file.
 165   scoped_ptr<CreateFileOperation> create_file_operation_;
 166
 167   // Note: This should remain the last member so it'll be destroyed and
 168   // invalidate the weak pointers before any other members are destroyed.
 169   base::WeakPtrFactory<CopyOperation> weak_ptr_factory_;
 170   DISALLOW_COPY_AND_ASSIGN(CopyOperation);
 171 };
 172
 173 }  // namespace file_system
 174 }  // namespace drive
 175
 176 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_COPY_OPERATION_H_