drive: Rename file_system::DriveOperations to 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"
@@ skipping 200 matching lines @@
   resource_metadata_->ResetOnUIThread(base::Bind(
       &FileSystem::ReloadAfterReset,
       weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetupChangeListLoader();
 
-  // Allocate the drive operation handlers.
-  drive_operations_.Init(this,  // OperationObserver
-                         scheduler_,
-                         resource_metadata_,
-                         cache_,
-                         this,  // FileSystemInterface
-                         drive_service_,
-                         blocking_task_runner_);
+  // Allocate the file system operation handlers.
+  operations_.Init(this,  // OperationObserver
+                   scheduler_,
+                   resource_metadata_,
+                   cache_,
+                   this,  // FileSystemInterface
+                   drive_service_,
+                   blocking_task_runner_);
 
   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: "
@@ skipping 84 matching lines @@
       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) {
 
-  drive_operations_.TransferFileFromRemoteToLocal(remote_src_file_path,
-                                                  local_dest_file_path,
-                                                  callback);
+  operations_.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) {
 
-  drive_operations_.TransferFileFromLocalToRemote(local_src_file_path,
-                                                  remote_dest_file_path,
-                                                  callback);
+  operations_.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());
-  drive_operations_.Copy(src_file_path, dest_file_path, callback);
+  operations_.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());
-  drive_operations_.Move(src_file_path, dest_file_path, callback);
+  operations_.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());
-  drive_operations_.Remove(file_path, is_recursive, callback);
+  operations_.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;
   }
 
-  drive_operations_.CreateDirectory(
+  operations_.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());
 
-  drive_operations_.CreateFile(file_path, is_exclusive, callback);
+  operations_.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());
 
-  drive_operations_.TouchFile(
+  operations_.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 713 matching lines @@
       callback);
 }
 
 void FileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const DriveClientContext& context,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  drive_operations_.UpdateFileByResourceId(resource_id, context, callback);
+  operations_.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 18 matching lines @@
                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());
 
-  drive_operations_.Search(search_query, next_feed, callback);
+  operations_.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 438 matching lines @@
   util::ConvertPlatformFileInfoToResourceEntry(*file_info, &entry_file_info);
   *entry->mutable_file_info() = entry_file_info;
   callback.Run(FILE_ERROR_OK, entry.Pass());
 }
 
 void FileSystem::CancelJobInScheduler(JobID id) {
   scheduler_->CancelJob(id);
 }
 
 }  // namespace drive