Remove drive::file_system::Operations.

chrome/browser/chromeos/drive/file_system.cc

 // Copyright (c) 2012 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/drive/file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/change_list_loader.h"
 #include "chrome/browser/chromeos/drive/change_list_processor.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
+#include "chrome/browser/chromeos/drive/file_system/copy_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/create_directory_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/create_file_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/download_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/move_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/remove_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/search_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/touch_operation.h"
+#include "chrome/browser/chromeos/drive/file_system/update_operation.h"
 #include "chrome/browser/chromeos/drive/file_system_observer.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/remove_stale_cache_files.h"
 #include "chrome/browser/chromeos/drive/resource_entry_conversion.h"
 #include "chrome/browser/chromeos/drive/search_metadata.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/drive_api_util.h"
 #include "chrome/browser/google_apis/drive_service_interface.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 67 matching lines @@
 void FileSystem::Reload() {
   resource_metadata_->ResetOnUIThread(base::Bind(
       &FileSystem::ReloadAfterReset,
       weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetupChangeListLoader();
-
-  // Allocate the file system operation handlers.
-  operations_.Init(this,  // OperationObserver
-                   scheduler_,
-                   resource_metadata_,
-                   cache_,
-                   this,  // FileSystemInterface
-                   drive_service_,
-                   blocking_task_runner_);
+  SetupOperations();
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableDriveHostedFiles);
 
   InitializePreferenceObserver();
 }
 
 void FileSystem::ReloadAfterReset(FileError error) {
   if (error != FILE_ERROR_OK) {
     LOG(ERROR) << "Failed to reset the resource metadata: "
                << FileErrorToString(error);
     return;
   }
 
   SetupChangeListLoader();
 
   change_list_loader_->LoadIfNeeded(
       DirectoryFetchInfo(),
       base::Bind(&FileSystem::OnUpdateChecked,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FileSystem::SetupChangeListLoader() {
   change_list_loader_.reset(new internal::ChangeListLoader(
       blocking_task_runner_, resource_metadata_, scheduler_));
   change_list_loader_->AddObserver(this);
 }
 
+void FileSystem::SetupOperations() {
+  file_system::OperationObserver* observer = this;
+  copy_operation_.reset(
+      new file_system::CopyOperation(blocking_task_runner_,
+                                     observer,
+                                     scheduler_,
+                                     resource_metadata_,
+                                     cache_,
+                                     this,
+                                     drive_service_));
+  create_directory_operation_.reset(new file_system::CreateDirectoryOperation(
+      blocking_task_runner_, observer, scheduler_, resource_metadata_));
+  create_file_operation_.reset(new file_system::CreateFileOperation(
+      blocking_task_runner_, observer, scheduler_, resource_metadata_, cache_));
+  move_operation_.reset(new file_system::MoveOperation(
+      observer, scheduler_, resource_metadata_));
+  remove_operation_.reset(new file_system::RemoveOperation(
+      observer, scheduler_, resource_metadata_, cache_));
+  touch_operation_.reset(new file_system::TouchOperation(
+      blocking_task_runner_, observer, scheduler_, resource_metadata_));
+  download_operation_.reset(new file_system::DownloadOperation(
+      blocking_task_runner_, observer, scheduler_, resource_metadata_, cache_));
+  update_operation_.reset(new file_system::UpdateOperation(
+      blocking_task_runner_, observer, scheduler_, resource_metadata_, cache_));
+  search_operation_.reset(new file_system::SearchOperation(
+      blocking_task_runner_, scheduler_, resource_metadata_));
+}
+
 void FileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "CheckForUpdates";
 
   if (change_list_loader_) {
     change_list_loader_->CheckForUpdates(
         base::Bind(&FileSystem::OnUpdateChecked,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
@@ skipping 55 matching lines @@
       entry.Pass(),
       base::Bind(&RunGetResourceEntryWithFilePathCallback,
                  callback,
                  file_path));
 }
 
 void FileSystem::TransferFileFromRemoteToLocal(
     const base::FilePath& remote_src_file_path,
     const base::FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
-
-  operations_.TransferFileFromRemoteToLocal(remote_src_file_path,
-                                            local_dest_file_path,
-                                            callback);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+  copy_operation_->TransferFileFromRemoteToLocal(remote_src_file_path,
+                                                 local_dest_file_path,
+                                                 callback);
 }
 
 void FileSystem::TransferFileFromLocalToRemote(
     const base::FilePath& local_src_file_path,
     const base::FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
-
-  operations_.TransferFileFromLocalToRemote(local_src_file_path,
-                                            remote_dest_file_path,
-                                            callback);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+  copy_operation_->TransferFileFromLocalToRemote(local_src_file_path,
+                                                 remote_dest_file_path,
+                                                 callback);
 }
 
 void FileSystem::Copy(const base::FilePath& src_file_path,
                       const base::FilePath& dest_file_path,
                       const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-  operations_.Copy(src_file_path, dest_file_path, callback);
+  copy_operation_->Copy(src_file_path, dest_file_path, callback);
 }
 
 void FileSystem::Move(const base::FilePath& src_file_path,
                       const base::FilePath& dest_file_path,
                       const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-  operations_.Move(src_file_path, dest_file_path, callback);
+  move_operation_->Move(src_file_path, dest_file_path, callback);
 }
 
 void FileSystem::Remove(const base::FilePath& file_path,
                         bool is_recursive,
                         const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-  operations_.Remove(file_path, is_recursive, callback);
+  remove_operation_->Remove(file_path, is_recursive, callback);
 }
 
 void FileSystem::CreateDirectory(
     const base::FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 11 matching lines @@
     const FileOperationCallback& callback,
     FileError load_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (load_error != FILE_ERROR_OK) {
     callback.Run(load_error);
     return;
   }
 
-  operations_.CreateDirectory(
+  create_directory_operation_->CreateDirectory(
       directory_path, is_exclusive, is_recursive, callback);
 }
 
 void FileSystem::CreateFile(const base::FilePath& file_path,
                             bool is_exclusive,
                             const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-
-  operations_.CreateFile(file_path, is_exclusive, callback);
+  create_file_operation_->CreateFile(file_path, is_exclusive, callback);
 }
 
 void FileSystem::TouchFile(const base::FilePath& file_path,
                            const base::Time& last_access_time,
                            const base::Time& last_modified_time,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!last_access_time.is_null());
   DCHECK(!last_modified_time.is_null());
   DCHECK(!callback.is_null());
-
-  operations_.TouchFile(
+  touch_operation_->TouchFile(
       file_path, last_access_time, last_modified_time, callback);
 }
 
 void FileSystem::Pin(const base::FilePath& file_path,
                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   GetResourceEntryByPath(file_path,
                          base::Bind(&FileSystem::PinAfterGetResourceEntryByPath,
@@ skipping 53 matching lines @@
 
   cache_->UnpinOnUIThread(entry->resource_id(),
                           entry->file_specific_info().file_md5(), callback);
 }
 
 void FileSystem::GetFileByPath(const base::FilePath& file_path,
                                const GetFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  operations_.EnsureFileDownloadedByPath(
+  download_operation_->EnsureFileDownloadedByPath(
       file_path,
       ClientContext(USER_INITIATED),
       GetFileContentInitializedCallback(),
       google_apis::GetContentCallback(),
       callback);
 }
 
 void FileSystem::GetFileByResourceId(
     const std::string& resource_id,
     const ClientContext& context,
     const GetFileCallback& get_file_callback,
     const google_apis::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!resource_id.empty());
   DCHECK(!get_file_callback.is_null());
 
-  operations_.EnsureFileDownloadedByResourceId(
+  download_operation_->EnsureFileDownloadedByResourceId(
       resource_id,
       context,
       GetFileContentInitializedCallback(),
       get_content_callback,
       get_file_callback);
 }
 
 void FileSystem::GetFileContentByPath(
     const base::FilePath& file_path,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const FileOperationCallback& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!initialized_callback.is_null());
   DCHECK(!get_content_callback.is_null());
   DCHECK(!completion_callback.is_null());
 
-  operations_.EnsureFileDownloadedByPath(
+  download_operation_->EnsureFileDownloadedByPath(
       file_path,
       ClientContext(USER_INITIATED),
       initialized_callback,
       get_content_callback,
       base::Bind(&GetFileCallbackToFileOperationCallbackAdapter,
                  completion_callback));
 }
 
 void FileSystem::GetResourceEntryByPath(
     const base::FilePath& file_path,
@@ skipping 212 matching lines @@
       entry->resource_id(),
       callback);
 }
 
 void FileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const ClientContext& context,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-
-  operations_.UpdateFileByResourceId(resource_id, context, callback);
+  update_operation_->UpdateFileByResourceId(resource_id, context, callback);
 }
 
 void FileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scheduler_->GetAboutResource(
       base::Bind(&FileSystem::OnGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr(),
@@ skipping 17 matching lines @@
   callback.Run(FILE_ERROR_OK,
                about_resource->quota_bytes_total(),
                about_resource->quota_bytes_used());
 }
 
 void FileSystem::Search(const std::string& search_query,
                         const GURL& next_feed,
                         const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-
-  operations_.Search(search_query, next_feed, callback);
+  search_operation_->Search(search_query, next_feed, callback);
 }
 
 void FileSystem::SearchMetadata(const std::string& query,
                                 int options,
                                 int at_most_num_matches,
                                 const SearchMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (hide_hosted_docs_)
     options |= SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS;
@@ skipping 153 matching lines @@
   // Open->Open->modify->Close->modify->Close; the second modify may not be
   // synchronized to the server since it is already Closed on the cache).
   if (open_files_.find(file_path) != open_files_.end()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, FILE_ERROR_IN_USE, base::FilePath()));
     return;
   }
   open_files_.insert(file_path);
 
-  operations_.EnsureFileDownloadedByPath(
+  download_operation_->EnsureFileDownloadedByPath(
       file_path,
       ClientContext(USER_INITIATED),
       GetFileContentInitializedCallback(),
       google_apis::GetContentCallback(),
       base::Bind(&FileSystem::OpenFileAfterFileDownloaded,
                  weak_ptr_factory_.GetWeakPtr(),
                  file_path,
                  base::Bind(&FileSystem::OnOpenFileFinished,
                             weak_ptr_factory_.GetWeakPtr(),
                             file_path,
@@ skipping 230 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   util::ConvertPlatformFileInfoToResourceEntry(*file_info, &entry_file_info);
   *entry->mutable_file_info() = entry_file_info;
   callback.Run(FILE_ERROR_OK, entry.Pass());
 }
 
 }  // namespace drive