Rename DocumentsServiceInterface to DriveServiceInterface.

chrome/browser/chromeos/gdata/gdata_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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/gdata/documents_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
+#include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_download_observer.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_protocol_handler.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/task_util.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 376 matching lines @@
   std::string resource_id;
   std::string md5;
 };
 
 
 // GDataFileSystem class implementation.
 
 GDataFileSystem::GDataFileSystem(
     Profile* profile,
     GDataCache* cache,
-    DocumentsServiceInterface* documents_service,
+    DriveServiceInterface* drive_service,
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
       cache_(cache),
       uploader_(uploader),
-      documents_service_(documents_service),
+      drive_service_(drive_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
       hide_hosted_docs_(false),
       blocking_task_runner_(blocking_task_runner),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  documents_service_->Initialize(profile_);
+  drive_service_->Initialize(profile_);
 
   directory_service_.reset(new GDataDirectoryService);
   feed_loader_.reset(new GDataWapiFeedLoader(directory_service_.get(),
-                                             documents_service_,
+                                             drive_service_,
                                              webapps_registry_,
                                              cache_,
                                              blocking_task_runner_));
   feed_loader_->AddObserver(this);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
@@ skipping 21 matching lines @@
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // This should be called from UI thread, from GDataSystemService shutdown.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->RemoveObserver(this);
 
   // Cancel all the in-flight operations.
   // This asynchronously cancels the URL fetch operations.
-  documents_service_->CancelAll();
+  drive_service_->CancelAll();
 }
 
 void GDataFileSystem::AddObserver(
     GDataFileSystemInterface::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void GDataFileSystem::RemoveObserver(
     GDataFileSystemInterface::Observer* observer) {
@@ skipping 445 matching lines @@
 }
 
 void GDataFileSystem::CopyDocumentToDirectory(
     const FilePath& dir_path,
     const std::string& resource_id,
     const FilePath::StringType& new_name,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  documents_service_->CopyDocument(resource_id, new_name,
+  drive_service_->CopyDocument(resource_id, new_name,
       base::Bind(&GDataFileSystem::OnCopyDocumentCompleted,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void GDataFileSystem::Rename(const FilePath& file_path,
                              const FilePath::StringType& new_name,
                              const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 37 matching lines @@
   FilePath::StringType file_name = new_name;
   if (entry_proto->has_file_specific_info() &&
       entry_proto->file_specific_info().is_hosted_document()) {
     FilePath new_file(file_name);
     if (new_file.Extension() ==
         entry_proto->file_specific_info().document_extension()) {
       file_name = new_file.RemoveExtension().value();
     }
   }
 
-  documents_service_->RenameResource(
+  drive_service_->RenameResource(
       GURL(entry_proto->edit_url()),
       file_name,
       base::Bind(&GDataFileSystem::RenameEntryLocally,
                  ui_weak_ptr_,
                  file_path,
                  file_name,
                  callback));
 }
 
 void GDataFileSystem::Move(const FilePath& src_file_path,
@@ skipping 127 matching lines @@
   scoped_ptr<GDataEntryProto> src_proto = result->first.proto.Pass();
   scoped_ptr<GDataEntryProto> dir_proto = result->second.proto.Pass();
 
   if (!dir_proto->file_info().is_directory()) {
     callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   const FilePath& file_path = result->first.path;
   const FilePath& dir_path = result->second.path;
-  documents_service_->AddResourceToDirectory(
+  drive_service_->AddResourceToDirectory(
       GURL(dir_proto->content_url()),
       GURL(src_proto->edit_url()),
       base::Bind(&GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
 void GDataFileSystem::RemoveEntryFromNonRootDirectory(
@@ skipping 37 matching lines @@
   }
 
   scoped_ptr<GDataEntryProto> entry_proto = result->first.proto.Pass();
   scoped_ptr<GDataEntryProto> dir_proto = result->second.proto.Pass();
 
   if (!dir_proto->file_info().is_directory()) {
     callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY, file_path);
     return;
   }
 
-  documents_service_->RemoveResourceFromDirectory(
+  drive_service_->RemoveResourceFromDirectory(
       GURL(dir_proto->content_url()),
       GURL(entry_proto->edit_url()),
       entry_proto->resource_id(),
       base::Bind(&GDataFileSystem::MoveEntryToRootDirectoryLocally,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
@@ skipping 36 matching lines @@
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(callback, error));
     }
     return;
   }
 
   DCHECK(entry_proto.get());
-  documents_service_->DeleteDocument(
+  drive_service_->DeleteDocument(
       GURL(entry_proto->edit_url()),
       base::Bind(&GDataFileSystem::OnRemovedDocument,
                  ui_weak_ptr_,
                  callback,
                  file_path));
 }
 
 void GDataFileSystem::CreateDirectory(
     const FilePath& directory_path,
     bool is_exclusive,
@@ skipping 56 matching lines @@
   // Do we have a parent directory here as well? We can't then create target
   // directory if this is not a recursive operation.
   if (directory_path !=  first_missing_path && !is_recursive) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
            base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
     }
     return;
   }
 
-  documents_service_->CreateDirectory(
+  drive_service_->CreateDirectory(
       last_parent_dir_url,
       first_missing_path.BaseName().value(),
       base::Bind(&GDataFileSystem::OnCreateDirectoryCompleted,
                  ui_weak_ptr_,
                  CreateDirectoryParams(
                      first_missing_path,
                      directory_path,
                      is_exclusive,
                      is_recursive,
                      callback)));
@@ skipping 274 matching lines @@
   // instead. This logic is rather complicated but here's how this works:
   //
   // Retrieve fresh file metadata from server. We will extract file size and
   // content url from there (we want to make sure used content url is not
   // stale).
   //
   // Check if we have enough space, based on the expected file size.
   // - if we don't have enough space, try to free up the disk space
   // - if we still don't have enough space, return "no space" error
   // - if we have enough space, start downloading the file from the server
-  documents_service_->GetDocumentEntry(
+  drive_service_->GetDocumentEntry(
       resource_id,
       base::Bind(&GDataFileSystem::OnGetDocumentEntry,
                  ui_weak_ptr_,
                  cache_file_path,
                  GetFileFromCacheParams(params.virtual_file_path,
                                         params.local_tmp_path,
                                         params.content_url,
                                         params.resource_id,
                                         params.md5,
                                         params.mime_type,
@@ skipping 66 matching lines @@
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(GDATA_FILE_ERROR_NO_SPACE,
                                    cache_file_path,
                                    params.mime_type,
                                    REGULAR_FILE);
     }
     return;
   }
 
   // We have enough disk space. Start downloading the file.
-  documents_service_->DownloadFile(
+  drive_service_->DownloadFile(
       params.virtual_file_path,
       params.local_tmp_path,
       content_url,
       base::Bind(&GDataFileSystem::OnFileDownloaded,
                  ui_weak_ptr_,
                  params),
       params.get_content_callback);
 }
 
 void GDataFileSystem::GetEntryInfoByPath(const FilePath& file_path,
@@ skipping 358 matching lines @@
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::GetAvailableSpaceOnUIThread,
                                ui_weak_ptr_,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetAvailableSpaceOnUIThread(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  documents_service_->GetAccountMetadata(
+  drive_service_->GetAccountMetadata(
       gdata::util::IsDriveV2ApiEnabled() ?
       base::Bind(&GDataFileSystem::OnGetAboutResource,
                  ui_weak_ptr_,
                  callback) :
       base::Bind(&GDataFileSystem::OnGetAvailableSpace,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetAvailableSpace(
@@ skipping 1183 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata