Rename gdata_errorcode.h to drive_api_error_codes.h

chrome/browser/drive/fake_drive_service.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/drive/fake_drive_service.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 22 matching lines @@
 using google_apis::CancelCallback;
 using google_apis::ChangeList;
 using google_apis::ChangeListCallback;
 using google_apis::ChangeResource;
 using google_apis::DownloadActionCallback;
 using google_apis::EntryActionCallback;
 using google_apis::FileList;
 using google_apis::FileListCallback;
 using google_apis::FileResource;
 using google_apis::FileResourceCallback;
-using google_apis::GDATA_FILE_ERROR;
-using google_apis::GDATA_NO_CONNECTION;
-using google_apis::GDATA_OTHER_ERROR;
-using google_apis::GDataErrorCode;
+using google_apis::DRIVE_FILE_ERROR;

[mtomasz, 2015/01/29 06:18:02]

nit: ditto

+using google_apis::DRIVE_NO_CONNECTION;
+using google_apis::DRIVE_OTHER_ERROR;
+using google_apis::DriveApiErrorCode;
 using google_apis::GetContentCallback;
 using google_apis::GetShareUrlCallback;
 using google_apis::HTTP_BAD_REQUEST;
 using google_apis::HTTP_CREATED;
 using google_apis::HTTP_FORBIDDEN;
 using google_apis::HTTP_NOT_FOUND;
 using google_apis::HTTP_NO_CONTENT;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
@@ skipping 39 matching lines @@
     if (!entry.file() ||
         entry.file()->title().find(value) == std::string::npos)
       return false;
   }
   return true;
 }
 
 void ScheduleUploadRangeCallback(const UploadRangeCallback& callback,
                                  int64 start_position,
                                  int64 end_position,
-                                 GDataErrorCode error,
+                                 DriveApiErrorCode error,
                                  scoped_ptr<FileResource> entry) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  UploadRangeResponse(error,
                                      start_position,
                                      end_position),
                  base::Passed(&entry)));
 }
 
 void FileListCallbackAdapter(const FileListCallback& callback,
-                             GDataErrorCode error,
+                             DriveApiErrorCode error,
                              scoped_ptr<ChangeList> change_list) {
   scoped_ptr<FileList> file_list;
   if (!change_list) {
     callback.Run(error, file_list.Pass());
     return;
   }
 
   file_list.reset(new FileList);
   file_list->set_next_link(change_list->next_link());
   for (size_t i = 0; i < change_list->items().size(); ++i) {
@@ skipping 19 matching lines @@
 void CallFileResouceCallback(const FileResourceCallback& callback,
                              const UploadRangeResponse& response,
                              scoped_ptr<FileResource> entry) {
   callback.Run(response.code, entry.Pass());
 }
 
 struct CallResumeUpload {
   CallResumeUpload() {}
   ~CallResumeUpload() {}
 
-  void Run(GDataErrorCode code, const GURL& upload_url) {
+  void Run(DriveApiErrorCode code, const GURL& upload_url) {
     if (service) {
       service->ResumeUpload(
           upload_url,
           /* start position */ 0,
           /* end position */ content_length,
           content_length,
           content_type,
           local_file_path,
           base::Bind(&CallFileResouceCallback, callback),
           progress_callback);
@@ skipping 361 matching lines @@
 CancelCallback FakeDriveService::GetFileResource(
     const std::string& resource_id,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry && entry->change_resource.file()) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, base::Passed(make_scoped_ptr(
             new FileResource(*entry->change_resource.file())))));
@@ skipping 11 matching lines @@
     const std::string& resource_id,
     const GURL& /* embed_origin */,
     const GetShareUrlCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    GURL()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, entry->share_url));
     return CancelCallback();
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND, GURL()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetAboutResource(
     const AboutResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<AboutResource> null;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION, base::Passed(&null)));
+                   DRIVE_NO_CONNECTION, base::Passed(&null)));
     return CancelCallback();
   }
 
   ++about_resource_load_count_;
   scoped_ptr<AboutResource> about_resource(new AboutResource(*about_resource_));
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS, base::Passed(&about_resource)));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetAppList(const AppListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   DCHECK(app_info_value_);
 
   if (offline_) {
     scoped_ptr<AppList> null;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(&null)));
     return CancelCallback();
   }
 
   ++app_list_load_count_;
   scoped_ptr<AppList> app_list(AppList::CreateFrom(*app_info_value_));
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, base::Passed(&app_list)));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::DeleteResource(
     const std::string& resource_id,
     const std::string& etag,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+        FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
@@ skipping 30 matching lines @@
 }
 
 CancelCallback FakeDriveService::TrashResource(
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+        FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
@@ skipping 28 matching lines @@
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!download_action_callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::FilePath()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry || entry->change_resource.file()->IsHostedDocument()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback, HTTP_NOT_FOUND, base::FilePath()));
     return CancelCallback();
@@ skipping 15 matching lines @@
           base::Bind(get_content_callback, HTTP_SUCCESS,
                      base::Passed(&content_for_callback)));
     }
   }
 
   if (!test_util::WriteStringToFile(local_cache_path, content_data)) {
     // Failed to write the content.
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback,
-                   GDATA_FILE_ERROR, base::FilePath()));
+                   DRIVE_FILE_ERROR, base::FilePath()));
     return CancelCallback();
   }
 
   if (!progress_callback.is_null()) {
     // See also the comment in ResumeUpload(). For testing that clients
     // can handle the case progress_callback is called multiple times,
     // here we invoke the callback twice.
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(progress_callback, file_size / 2, file_size));
@@ skipping 15 matching lines @@
     const std::string& new_title,
     const base::Time& last_modified,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   const std::string& parent_resource_id = in_parent_resource_id.empty() ?
       GetRootResourceId() : in_parent_resource_id;
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
@@ skipping 50 matching lines @@
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const base::Time& last_viewed_by_me,
     const google_apis::FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION,
+        FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION,
                               base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
@@ skipping 47 matching lines @@
 
 CancelCallback FakeDriveService::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+        FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
@@ skipping 19 matching lines @@
 
 CancelCallback FakeDriveService::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+        FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
@@ skipping 38 matching lines @@
     const std::string& parent_resource_id,
     const std::string& title,
     const UploadNewFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+        base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   if (parent_resource_id != GetRootResourceId() &&
       !entries_.count(parent_resource_id)) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
@@ skipping 17 matching lines @@
     int64 content_length,
     const std::string& resource_id,
     const UploadExistingFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+        base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
@@ skipping 47 matching lines @@
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   FileResourceCallback completion_callback
       = base::Bind(&ScheduleUploadRangeCallback,
                    callback, start_position, end_position);
 
   if (offline_) {
-    completion_callback.Run(GDATA_NO_CONNECTION, scoped_ptr<FileResource>());
+    completion_callback.Run(DRIVE_NO_CONNECTION, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   if (!upload_sessions_.count(upload_url)) {
     completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   UploadSession* session = &upload_sessions_[upload_url];
 
@@ skipping 20 matching lines @@
 
   if (content_length != end_position) {
     session->uploaded_size = end_position;
     completion_callback.Run(HTTP_RESUME_INCOMPLETE, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   std::string content_data;
   if (!base::ReadFileToString(local_file_path, &content_data)) {
     session->uploaded_size = end_position;
-    completion_callback.Run(GDATA_FILE_ERROR, scoped_ptr<FileResource>());
+    completion_callback.Run(DRIVE_FILE_ERROR, scoped_ptr<FileResource>());
     return CancelCallback();
   }
   session->uploaded_size = end_position;
 
   // |resource_id| is empty if the upload is for new file.
   if (session->resource_id.empty()) {
     DCHECK(!session->parent_resource_id.empty());
     DCHECK(!session->title.empty());
     const EntryInfo* new_entry = AddNewEntry(
         "",  // auto generate resource id.
@@ skipping 115 matching lines @@
 
 CancelCallback FakeDriveService::UninstallApp(
     const std::string& app_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback, google_apis::GDATA_NO_CONNECTION));
+        base::Bind(callback, google_apis::DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   // Find app_id from app_info_value_ and delete.
   base::ListValue* items = NULL;
   if (!app_info_value_->GetList("items", &items)) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, google_apis::HTTP_NOT_FOUND));
     return CancelCallback();
@@ skipping 37 matching lines @@
     const std::string& title,
     bool shared_with_me,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
   const EntryInfo* new_entry = AddNewEntry(resource_id,
                                            content_type,
                                            content_data,
                                            parent_resource_id,
                                            title,
                                            shared_with_me);
@@ skipping 22 matching lines @@
     const std::string& directory_title,
     const AddNewDirectoryOptions& options,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   const EntryInfo* new_entry = AddNewEntry(resource_id,
                                            util::kDriveFolderMimeType,
                                            "",  // content_data
                                            parent_resource_id,
                                            directory_title,
                                            false);  // shared_with_me
@@ skipping 21 matching lines @@
     const std::string& resource_id,
     const base::Time& last_modified_time,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   file->set_modified_date(last_modified_time);
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
                  base::Passed(make_scoped_ptr(new FileResource(*file)))));
 }
 
-google_apis::GDataErrorCode FakeDriveService::SetUserPermission(
+google_apis::DriveApiErrorCode FakeDriveService::SetUserPermission(
     const std::string& resource_id,
     google_apis::drive::PermissionRole user_permission) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry)
     return HTTP_NOT_FOUND;
 
   entry->user_permission = user_permission;
   return HTTP_SUCCESS;
@@ skipping 117 matching lines @@
     const std::string& search_query,
     const std::string& directory_resource_id,
     int start_offset,
     int max_results,
     int* load_counter,
     const ChangeListCallback& callback) {
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   GDATA_NO_CONNECTION,
+                   DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<ChangeList>())));
     return;
   }
 
   // Filter out entries per parameters like |directory_resource_id| and
   // |search_query|.
   ScopedVector<ChangeResource> entries;
   int num_entries_matched = 0;
   for (EntryInfoMap::iterator it = entries_.begin(); it != entries_.end();
        ++it) {
@@ skipping 114 matching lines @@
 
   NOTREACHED();
   return CancelCallback();
 }
 
 void FakeDriveService::NotifyObservers() {
   FOR_EACH_OBSERVER(ChangeObserver, change_observers_, OnNewChangeAvailable());
 }
 
 }  // namespace drive