Drive: Remove gdata_params.h

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"
@@ skipping 435 matching lines @@
 // GDataFileSystem::GetFileFromCacheParams struct implementation.
 struct GDataFileSystem::GetFileFromCacheParams {
   GetFileFromCacheParams(
       const FilePath& virtual_file_path,
       const FilePath& local_tmp_path,
       const GURL& content_url,
       const std::string& resource_id,
       const std::string& md5,
       const std::string& mime_type,
       const GetFileCallback& get_file_callback,
-      const GetDownloadDataCallback& get_download_data_callback);
+      const GetContentCallback& get_content_callback);
   ~GetFileFromCacheParams();
 
   FilePath virtual_file_path;
   FilePath local_tmp_path;
   GURL content_url;
   std::string resource_id;
   std::string md5;
   std::string mime_type;
   const GetFileCallback get_file_callback;
-  const GetDownloadDataCallback get_download_data_callback;
+  const GetContentCallback get_content_callback;
 };
 
 GDataFileSystem::GetFileFromCacheParams::GetFileFromCacheParams(
     const FilePath& virtual_file_path,
     const FilePath& local_tmp_path,
     const GURL& content_url,
     const std::string& resource_id,
     const std::string& md5,
     const std::string& mime_type,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback)
+    const GetContentCallback& get_content_callback)
     : virtual_file_path(virtual_file_path),
       local_tmp_path(local_tmp_path),
       content_url(content_url),
       resource_id(resource_id),
       md5(md5),
       mime_type(mime_type),
       get_file_callback(get_file_callback),
-      get_download_data_callback(get_download_data_callback) {
+      get_content_callback(get_content_callback) {
 }
 
 GDataFileSystem::GetFileFromCacheParams::~GetFileFromCacheParams() {
 }
 
 // GDataFileSystem::StartFileUploadParams implementation.
 struct GDataFileSystem::StartFileUploadParams {
   StartFileUploadParams(const FilePath& in_local_file_path,
                         const FilePath& in_remote_file_path,
                         const FileOperationCallback& in_callback)
@@ skipping 213 matching lines @@
     const FilePath& remote_src_file_path,
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetFileByPath(remote_src_file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForTransferFile,
                  ui_weak_ptr_,
                  local_dest_file_path,
                  callback),
-      GetDownloadDataCallback());
+      GetContentCallback());
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemote(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure the destination directory exists.
   directory_service_->GetEntryInfoByPath(
@@ skipping 245 matching lines @@
     return;
   }
 
   // TODO(benchan): Reimplement this once the server API supports
   // copying of regular files directly on the server side.
   GetFileByPath(src_file_path,
                 base::Bind(&GDataFileSystem::OnGetFileCompleteForCopy,
                            ui_weak_ptr_,
                            dest_file_path,
                            callback),
-                GetDownloadDataCallback());
+                GetContentCallback());
 }
 
 void GDataFileSystem::OnGetFileCompleteForCopy(
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& local_file_path,
     const std::string& unused_mime_type,
     GDataFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 484 matching lines @@
 
   // No entry found at |file_path|. Let's create a brand new file.
   // For now, it is implemented by uploading an empty file (/dev/null).
   // TODO(kinaba): http://crbug.com/135143. Implement in a nicer way.
   TransferRegularFile(FilePath(kEmptyFilePath), file_path, callback);
 }
 
 void GDataFileSystem::GetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback) {
+    const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetFileByPathOnUIThread,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
-                 CreateRelayCallback(get_download_data_callback)));
+                 CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::GetFileByPathOnUIThread(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback) {
+    const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   directory_service_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
-                 CreateRelayCallback(get_download_data_callback)));
+                 CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback,
+    const GetContentCallback& get_content_callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If |error| == PLATFORM_FILE_OK then |entry_proto| must be valid.
   DCHECK(error != GDATA_FILE_OK ||
          (entry_proto.get() && !entry_proto->resource_id().empty()));
   GetResolvedFileByPath(file_path,
                         get_file_callback,
-                        get_download_data_callback,
+                        get_content_callback,
                         error,
                         entry_proto.get());
 }
 
 void GDataFileSystem::GetResolvedFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback,
+    const GetContentCallback& get_content_callback,
     GDataFileError error,
     const GDataEntryProto* entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
   if (error != GDATA_FILE_OK) {
     if (!get_file_callback.is_null()) {
       MessageLoop::current()->PostTask(
@@ skipping 51 matching lines @@
           &GDataFileSystem::OnGetFileFromCache,
           ui_weak_ptr_,
           GetFileFromCacheParams(
               file_path,
               local_tmp_path,
               GURL(entry_proto->content_url()),
               entry_proto->resource_id(),
               entry_proto->file_specific_info().file_md5(),
               entry_proto->file_specific_info().content_mime_type(),
               get_file_callback,
-              get_download_data_callback)));
+              get_content_callback)));
 }
 
 void GDataFileSystem::GetFileByResourceId(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback) {
+    const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(get_file_callback),
-                 CreateRelayCallback(get_download_data_callback)));
+                 CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::GetFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback) {
+    const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::GetFileByEntryOnUIThread,
                  ui_weak_ptr_,
                  get_file_callback,
-                 get_download_data_callback));
+                 get_content_callback));
 }
 
 void GDataFileSystem::GetFileByEntryOnUIThread(
     const GetFileCallback& get_file_callback,
-    const GetDownloadDataCallback& get_download_data_callback,
+    const GetContentCallback& get_content_callback,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath file_path;
   if (entry) {
     GDataFile* file = entry->AsGDataFile();
     if (file)
       file_path = file->GetFilePath();
   }
 
   // Report an error immediately if the file for the resource ID is not
   // found.
   if (file_path.empty()) {
     if (!get_file_callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(get_file_callback,
                      GDATA_FILE_ERROR_NOT_FOUND,
                      FilePath(),
                      std::string(),
                      REGULAR_FILE));
     }
     return;
   }
 
-  GetFileByPath(file_path, get_file_callback, get_download_data_callback);
+  GetFileByPath(file_path, get_file_callback, get_content_callback);
 }
 
 void GDataFileSystem::OnGetFileFromCache(const GetFileFromCacheParams& params,
                                          GDataFileError error,
                                          const std::string& resource_id,
                                          const std::string& md5,
                                          const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Have we found the file in cache? If so, return it back to the caller.
@@ skipping 23 matching lines @@
       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,
                                         params.get_file_callback,
-                                        params.get_download_data_callback)));
+                                        params.get_content_callback)));
 }
 
 void GDataFileSystem::OnGetDocumentEntry(const FilePath& cache_file_path,
                                          const GetFileFromCacheParams& params,
                                          GDataErrorCode status,
                                          scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = util::GDataToGDataFileError(status);
 
@@ skipping 64 matching lines @@
   }
 
   // We have enough disk space. Start downloading the file.
   documents_service_->DownloadFile(
       params.virtual_file_path,
       params.local_tmp_path,
       content_url,
       base::Bind(&GDataFileSystem::OnFileDownloaded,
                  ui_weak_ptr_,
                  params),
-      params.get_download_data_callback);
+      params.get_content_callback);
 }
 
 void GDataFileSystem::GetEntryInfoByPath(const FilePath& file_path,
                                          const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetEntryInfoByPathAsyncOnUIThread,
                  ui_weak_ptr_,
                  file_path,
@@ skipping 1266 matching lines @@
 
   DCHECK(!entry_proto->resource_id().empty());
   GetResolvedFileByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForOpenFile,
                  ui_weak_ptr_,
                  callback,
                  GetFileCompleteForOpenParams(
                      entry_proto->resource_id(),
                      entry_proto->file_specific_info().file_md5())),
-      GetDownloadDataCallback(),
+      GetContentCallback(),
       error,
       entry_proto.get());
 }
 
 void GDataFileSystem::OnGetFileCompleteForOpenFile(
     const OpenFileCallback& callback,
     const GetFileCompleteForOpenParams& entry_proto,
     GDataFileError error,
     const FilePath& file_path,
     const std::string& mime_type,
@@ skipping 334 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata