Rename gdata_errorcode.h to drive_api_error_codes.h

chrome/browser/chromeos/drive/job_scheduler_unittest.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/job_scheduler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 14 matching lines @@
 
 namespace drive {
 
 namespace {
 
 // Dummy value passed for the |expected_file_size| parameter of DownloadFile().
 const int64 kDummyDownloadFileSize = 0;
 
 void CopyTitleFromFileResourceCallback(
     std::vector<std::string>* title_list_out,
-    google_apis::GDataErrorCode error_in,
+    google_apis::DriveApiErrorCode error_in,
     scoped_ptr<google_apis::FileResource> entry_in) {
   title_list_out->push_back(entry_in->title());
 }
 
 class JobListLogger : public JobListObserver {
  public:
   enum EventType {
     ADDED,
     UPDATED,
     DONE,
@@ skipping 56 matching lines @@
   }
 
   google_apis::CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const UploadNewFileOptions& options,
       const google_apis::InitiateUploadCallback& callback) override {
     if (upload_new_file_cancelable_)
-      return base::Bind(callback, google_apis::GDATA_CANCELLED, GURL());
+      return base::Bind(callback, google_apis::DRIVE_CANCELLED, GURL());
 
     return FakeDriveService::InitiateUploadNewFile(content_type,
                                                    content_length,
                                                    parent_resource_id,
                                                    title,
                                                    options,
                                                    callback);
   }
 
  private:
@@ skipping 62 matching lines @@
   scoped_ptr<test_util::FakeNetworkChangeNotifier>
       fake_network_change_notifier_;
   scoped_ptr<EventLogger> logger_;
   scoped_ptr<CancelTestableFakeDriveService> fake_drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
 };
 
 TEST_F(JobSchedulerTest, GetAboutResource) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &about_resource));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(about_resource);
 }
 
 TEST_F(JobSchedulerTest, GetAppList) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::AppList> app_list;
 
   scheduler_->GetAppList(
       google_apis::test_util::CreateCopyResultCallback(&error, &app_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(app_list);
 }
 
 TEST_F(JobSchedulerTest, GetAllFileList) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileList> file_list;
 
   scheduler_->GetAllFileList(
       google_apis::test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 }
 
 TEST_F(JobSchedulerTest, GetFileListInDirectory) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileList> file_list;
 
   scheduler_->GetFileListInDirectory(
       fake_drive_service_->GetRootResourceId(),
       google_apis::test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 }
 
 TEST_F(JobSchedulerTest, Search) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileList> file_list;
 
   scheduler_->Search(
       "File",  // search query
       google_apis::test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 }
 
 TEST_F(JobSchedulerTest, GetChangeList) {
   ConnectToWifi();
 
   int64 old_largest_change_id =
       fake_drive_service_->about_resource().largest_change_id();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
   // Create a new directory.
   {
     scoped_ptr<google_apis::FileResource> entry;
     fake_drive_service_->AddNewDirectory(
         fake_drive_service_->GetRootResourceId(),
         "new directory",
         DriveServiceInterface::AddNewDirectoryOptions(),
         google_apis::test_util::CreateCopyResultCallback(
             &error, &entry));
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(google_apis::HTTP_CREATED, error);
   }
 
-  error = google_apis::GDATA_OTHER_ERROR;
+  error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::ChangeList> change_list;
   scheduler_->GetChangeList(
       old_largest_change_id + 1,
       google_apis::test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(change_list);
 }
 
 TEST_F(JobSchedulerTest, GetRemainingChangeList) {
   ConnectToWifi();
   fake_drive_service_->set_default_max_results(2);
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::ChangeList> change_list;
 
   scheduler_->GetChangeList(
       0,
       google_apis::test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(change_list);
 
   // Keep the next url before releasing the |change_list|.
   GURL next_url(change_list->next_link());
 
-  error = google_apis::GDATA_OTHER_ERROR;
+  error = google_apis::DRIVE_OTHER_ERROR;
   change_list.reset();
 
   scheduler_->GetRemainingChangeList(
       next_url,
       google_apis::test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(change_list);
 }
 
 TEST_F(JobSchedulerTest, GetRemainingFileList) {
   ConnectToWifi();
   fake_drive_service_->set_default_max_results(2);
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileList> file_list;
 
   scheduler_->GetFileListInDirectory(
       fake_drive_service_->GetRootResourceId(),
       google_apis::test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 
   // Keep the next url before releasing the |file_list|.
   GURL next_url(file_list->next_link());
 
-  error = google_apis::GDATA_OTHER_ERROR;
+  error = google_apis::DRIVE_OTHER_ERROR;
   file_list.reset();
 
   scheduler_->GetRemainingFileList(
       next_url,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 }
 
 TEST_F(JobSchedulerTest, GetFileResource) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->GetFileResource(
       "2_file_resource_id",  // resource ID
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, GetShareUrl) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   GURL share_url;
 
   scheduler_->GetShareUrl(
       "2_file_resource_id",  // resource ID
       GURL("chrome-extension://test-id/"), // embed origin
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &share_url));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_FALSE(share_url.is_empty());
 }
 
 TEST_F(JobSchedulerTest, TrashResource) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
   scheduler_->TrashResource(
       "2_file_resource_id",
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(JobSchedulerTest, CopyResource) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->CopyResource(
       "2_file_resource_id",  // resource ID
       "1_folder_resource_id",  // parent resource ID
       "New Document",  // new title
       base::Time(),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, UpdateResource) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->UpdateResource(
       "2_file_resource_id",  // resource ID
       "1_folder_resource_id",  // parent resource ID
       "New Document",  // new title
       base::Time(),
       base::Time(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, AddResourceToDirectory) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
   scheduler_->AddResourceToDirectory(
       "1_folder_resource_id",
       "2_file_resource_id",
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(JobSchedulerTest, RemoveResourceFromDirectory) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
   scheduler_->RemoveResourceFromDirectory(
       "1_folder_resource_id",
       "subdirectory_file_1_id",  // resource ID
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_NO_CONTENT, error);
 }
 
 TEST_F(JobSchedulerTest, AddNewDirectory) {
   ConnectToWifi();
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),  // Root directory.
       "New Directory",
       DriveServiceInterface::AddNewDirectoryOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_CREATED, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, PriorityHandling) {
   // Saturate the metadata job queue with uninteresting jobs to prevent
   // following jobs from starting.
-  google_apis::GDataErrorCode error_dontcare = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error_dontcare =
+      google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry_dontcare;
   for (int i = 0; i < GetMetadataQueueMaxJobCount(); ++i) {
     std::string resource_id("2_file_resource_id");
     scheduler_->GetFileResource(
         resource_id,
         ClientContext(USER_INITIATED),
         google_apis::test_util::CreateCopyResultCallback(&error_dontcare,
                                                          &entry_dontcare));
   }
 
@@ skipping 36 matching lines @@
   EXPECT_EQ(title_4, titles[1]);
   EXPECT_EQ(title_2, titles[2]);
   EXPECT_EQ(title_3, titles[3]);
 }
 
 TEST_F(JobSchedulerTest, NoConnectionUserInitiated) {
   ConnectToNone();
 
   std::string resource_id("2_file_resource_id");
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scheduler_->GetFileResource(
       resource_id,
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(google_apis::GDATA_NO_CONNECTION, error);
+  EXPECT_EQ(google_apis::DRIVE_NO_CONNECTION, error);
 }
 
 TEST_F(JobSchedulerTest, NoConnectionBackground) {
   ConnectToNone();
 
   std::string resource_id("2_file_resource_id");
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scheduler_->GetFileResource(
       resource_id,
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(entry);
 
   // Reconnect to the net.
@@ skipping 10 matching lines @@
 
   // Disable fetching over cellular network.
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
-  google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode download_error =
+      google_apis::DRIVE_OTHER_ERROR;
   base::FilePath output_file_path;
   scheduler_->DownloadFile(
       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
       kDummyDownloadFileSize,
       kOutputFilePath,
       "2_file_resource_id",
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(
           &download_error, &output_file_path),
       google_apis::GetContentCallback());
   // Metadata should still work
-  google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode metadata_error =
+      google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
 
   // Try to get the metadata
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &metadata_error, &about_resource));
   base::RunLoop().RunUntilIdle();
 
   // Check the metadata
   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
   ASSERT_TRUE(about_resource);
 
   // Check the download
-  EXPECT_EQ(google_apis::GDATA_OTHER_ERROR, download_error);
+  EXPECT_EQ(google_apis::DRIVE_OTHER_ERROR, download_error);
 
   // Switch to a Wifi connection
   ConnectToWifi();
 
   base::RunLoop().RunUntilIdle();
 
   // Check the download again
   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
   std::string content;
   EXPECT_EQ(output_file_path, kOutputFilePath);
   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
   EXPECT_EQ("This is some test content.", content);
 }
 
 TEST_F(JobSchedulerTest, DownloadFileWimaxDisabled) {
   ConnectToWimax();
 
   // Disable fetching over cellular network.
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
-  google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode download_error =
+      google_apis::DRIVE_OTHER_ERROR;
   base::FilePath output_file_path;
   scheduler_->DownloadFile(
       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
       kDummyDownloadFileSize,
       kOutputFilePath,
       "2_file_resource_id",
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(
           &download_error, &output_file_path),
       google_apis::GetContentCallback());
   // Metadata should still work
-  google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode metadata_error =
+      google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
 
   // Try to get the metadata
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &metadata_error, &about_resource));
   base::RunLoop().RunUntilIdle();
 
   // Check the metadata
   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
   ASSERT_TRUE(about_resource);
 
   // Check the download
-  EXPECT_EQ(google_apis::GDATA_OTHER_ERROR, download_error);
+  EXPECT_EQ(google_apis::DRIVE_OTHER_ERROR, download_error);
 
   // Switch to a Wifi connection
   ConnectToWifi();
 
   base::RunLoop().RunUntilIdle();
 
   // Check the download again
   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
   std::string content;
   EXPECT_EQ(output_file_path, kOutputFilePath);
   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
   EXPECT_EQ("This is some test content.", content);
 }
 
 TEST_F(JobSchedulerTest, DownloadFileCellularEnabled) {
   ConnectToCellular();
 
   // Enable fetching over cellular network.
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, false);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
-  google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode download_error =
+      google_apis::DRIVE_OTHER_ERROR;
   base::FilePath output_file_path;
   scheduler_->DownloadFile(
       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
       kDummyDownloadFileSize,
       kOutputFilePath,
       "2_file_resource_id",
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(
           &download_error, &output_file_path),
       google_apis::GetContentCallback());
   // Metadata should still work
-  google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode metadata_error =
+      google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
 
   // Try to get the metadata
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &metadata_error, &about_resource));
   base::RunLoop().RunUntilIdle();
 
   // Check the metadata
   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
@@ skipping 12 matching lines @@
 
   // Enable fetching over cellular network.
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, false);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
-  google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode download_error =
+      google_apis::DRIVE_OTHER_ERROR;
   base::FilePath output_file_path;
   scheduler_->DownloadFile(
       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
       kDummyDownloadFileSize,
       kOutputFilePath,
       "2_file_resource_id",
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(
           &download_error, &output_file_path),
       google_apis::GetContentCallback());
   // Metadata should still work
-  google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode metadata_error =
+      google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
 
   // Try to get the metadata
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &metadata_error, &about_resource));
   base::RunLoop().RunUntilIdle();
 
   // Check the metadata
   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
@@ skipping 11 matching lines @@
   JobListLogger logger;
   scheduler_->AddObserver(&logger);
 
   // Disable background upload/download.
   ConnectToWimax();
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scoped_ptr<google_apis::AboutResource> about_resource;
   base::FilePath path;
 
   std::set<JobType> expected_types;
 
   // Add many jobs.
   expected_types.insert(TYPE_ADD_NEW_DIRECTORY);
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),
@@ skipping 101 matching lines @@
 
 TEST_F(JobSchedulerTest, JobInfoProgress) {
   JobListLogger logger;
   scheduler_->AddObserver(&logger);
 
   ConnectToWifi();
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   base::FilePath path;
 
   // Download job.
   scheduler_->DownloadFile(
       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
       kDummyDownloadFileSize,
       temp_dir.path().AppendASCII("whatever.txt"),
       "2_file_resource_id",
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error, &path),
       google_apis::GetContentCallback());
   base::RunLoop().RunUntilIdle();
 
   std::vector<int64> download_progress;
   logger.GetProgressInfo(TYPE_DOWNLOAD_FILE, &download_progress);
   ASSERT_TRUE(!download_progress.empty());
   EXPECT_TRUE(base::STLIsSorted(download_progress));
   EXPECT_GE(download_progress.front(), 0);
   EXPECT_LE(download_progress.back(), 26);
 
   // Upload job.
   path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(path, "Hello"));
-  google_apis::GDataErrorCode upload_error =
-      google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode upload_error =
+      google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("drive/new_file.txt"),
       path,
       "dummy title",
       "plain/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(BACKGROUND),
@@ skipping 13 matching lines @@
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
 
   // To create a pending job for testing, set the mode to cellular connection
   // and issue BACKGROUND jobs.
   ConnectToCellular();
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Start the first job and record its job ID.
-  google_apis::GDataErrorCode error1 = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error1 = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("dummy/path"),
       upload_path,
       "dummy title 1",
       "text/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
 
   const std::vector<JobInfo>& jobs = scheduler_->GetJobInfoList();
   ASSERT_EQ(1u, jobs.size());
   ASSERT_EQ(STATE_NONE, jobs[0].state);  // Not started yet.
   JobID first_job_id = jobs[0].job_id;
 
   // Start the second job.
-  google_apis::GDataErrorCode error2 = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error2 = google_apis::DRIVE_OTHER_ERROR;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("dummy/path"),
       upload_path,
       "dummy title 2",
       "text/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error2, &entry));
 
   // Cancel the first one.
   scheduler_->CancelJob(first_job_id);
 
   // Only the first job should be cancelled.
   ConnectToWifi();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(google_apis::GDATA_CANCELLED, error1);
+  EXPECT_EQ(google_apis::DRIVE_CANCELLED, error1);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 TEST_F(JobSchedulerTest, CancelRunningJob) {
   ConnectToWifi();
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
 
   // Run as a cancelable task.
   fake_drive_service_->set_upload_new_file_cancelable(true);
-  google_apis::GDataErrorCode error1 = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error1 = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("dummy/path"),
       upload_path,
       "dummy title 1",
       "text/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
 
   const std::vector<JobInfo>& jobs = scheduler_->GetJobInfoList();
   ASSERT_EQ(1u, jobs.size());
   ASSERT_EQ(STATE_RUNNING, jobs[0].state);  // It's running.
   JobID first_job_id = jobs[0].job_id;
 
   // Start the second job normally.
   fake_drive_service_->set_upload_new_file_cancelable(false);
-  google_apis::GDataErrorCode error2 = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode error2 = google_apis::DRIVE_OTHER_ERROR;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("dummy/path"),
       upload_path,
       "dummy title 2",
       "text/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error2, &entry));
 
   // Cancel the first one.
   scheduler_->CancelJob(first_job_id);
 
   // Only the first job should be cancelled.
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(google_apis::GDATA_CANCELLED, error1);
+  EXPECT_EQ(google_apis::DRIVE_CANCELLED, error1);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 }  // namespace drive