Rename gdata_errorcode.h to drive_api_error_codes.h

chrome/browser/chromeos/drive/sync_client_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/sync_client.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 24 matching lines @@
 namespace internal {
 
 namespace {
 
 // The content of files initially stored in the cache.
 const char kLocalContent[] = "Hello!";
 
 // The content of files stored in the service.
 const char kRemoteContent[] = "World!";
 
-// SyncClientTestDriveService will return GDATA_CANCELLED when a request is
+// SyncClientTestDriveService will return DRIVE_CANCELLED when a request is
 // made with the specified resource ID.
 class SyncClientTestDriveService : public ::drive::FakeDriveService {
  public:
   SyncClientTestDriveService() : download_file_count_(0) {}
 
   // FakeDriveService override:
   google_apis::CancelCallback DownloadFile(
       const base::FilePath& local_cache_path,
       const std::string& resource_id,
       const google_apis::DownloadActionCallback& download_action_callback,
       const google_apis::GetContentCallback& get_content_callback,
       const google_apis::ProgressCallback& progress_callback) override {
     ++download_file_count_;
     if (resource_id == resource_id_to_be_cancelled_) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(download_action_callback,
-                     google_apis::GDATA_CANCELLED,
+                     google_apis::DRIVE_CANCELLED,
                      base::FilePath()));
       return google_apis::CancelCallback();
     }
     if (resource_id == resource_id_to_be_paused_) {
       paused_action_ = base::Bind(download_action_callback,
-                                  google_apis::GDATA_OTHER_ERROR,
+                                  google_apis::DRIVE_OTHER_ERROR,
                                   base::FilePath());
       return google_apis::CancelCallback();
     }
     return FakeDriveService::DownloadFile(local_cache_path,
                                           resource_id,
                                           download_action_callback,
                                           get_content_callback,
                                           progress_callback);
   }
 
@@ skipping 71 matching lines @@
                                       cache_.get(),
                                       loader_controller_.get(),
                                       temp_dir_.path()));
 
     // Disable delaying so that DoSyncLoop() starts immediately.
     sync_client_->set_delay_for_testing(base::TimeDelta::FromSeconds(0));
   }
 
   // Adds a file to the service root and |resource_ids_|.
   void AddFileEntry(const std::string& title) {
-    google_apis::GDataErrorCode error = google_apis::GDATA_FILE_ERROR;
+    google_apis::DriveApiErrorCode error = google_apis::DRIVE_FILE_ERROR;
     scoped_ptr<google_apis::FileResource> entry;
     drive_service_->AddNewFile(
         "text/plain",
         kRemoteContent,
         drive_service_->GetRootResourceId(),
         title,
         false,  // shared_with_me
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(google_apis::HTTP_CREATED, error);
@@ skipping 112 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryById(GetLocalId("baz"), &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
 
   // Dirty file gets uploaded.
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryById(GetLocalId("dirty"), &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
 
   // Removed entry is not found.
-  google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
+  google_apis::DriveApiErrorCode status = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   drive_service_->GetFileResource(
       resource_ids_["removed"],
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_TRUE(server_entry->labels().is_trashed());
 
   // Moved entry was moved.
-  status = google_apis::GDATA_OTHER_ERROR;
+  status = google_apis::DRIVE_OTHER_ERROR;
   drive_service_->GetFileResource(
       resource_ids_["moved"],
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ("moved_new_title", server_entry->title());
 }
 
 TEST_F(SyncClientTest, AddFetchTask) {
@@ skipping 195 matching lines @@
       local_id, google_apis::test_util::CreateCopyResultCallback(&error)));
 
   base::RunLoop().RunUntilIdle();
 
   // The callback is called.
   EXPECT_EQ(FILE_ERROR_OK, error);
 }
 
 }  // namespace internal
 }  // namespace drive