copy_operation.h revision 6e8cce623b6e4fe0c9e4af605d675dd9d0338c38 
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/gdata_errorcode.h"
17
18namespace base {
19class FilePath;
20class SequencedTaskRunner;
21class Time;
22}  // namespace base
23
24namespace google_apis {
25class FileResource;
26}  // namespace google_apis
27
28namespace drive {
29
30class JobScheduler;
31class ResourceEntry;
32
33namespace internal {
34class FileCache;
35class ResourceMetadata;
36}  // namespace internal
37
38namespace file_system {
39
40class CreateFileOperation;
41class 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.
46class 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::GDataErrorCode 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_
179