Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_file_system_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 41 matching lines @@
   const char* path;
   const bool is_directory;
 };
 
 // Callback to GDataFileSystem::Search used in ContentSearch tests.
 // Verifies returned vector of results.
 void DriveSearchCallback(
     MessageLoop* message_loop,
     const SearchResultPair* expected_results,
     size_t expected_results_size,
-    GDataFileError error,
+    DriveFileError error,
     const GURL& next_feed,
     scoped_ptr<std::vector<SearchResultInfo> > results) {
   ASSERT_TRUE(results.get());
   ASSERT_EQ(expected_results_size, results->size());
 
   for (size_t i = 0; i < results->size(); i++) {
     EXPECT_EQ(FilePath(expected_results[i].path),
               results->at(i).path);
     EXPECT_EQ(expected_results[i].is_directory,
               results->at(i).is_directory);
@@ skipping 86 matching lines @@
     // Used for TransferFileFromLocalToRemote_RegularFile test.
     scoped_ptr<base::Value> value(LoadJSONFile("uploaded_file.json"));
     scoped_ptr<DocumentEntry> document_entry(
         DocumentEntry::ExtractAndParse(*value));
     upload_file_info->entry = document_entry.Pass();
 
     // Run the completion callback.
     const UploadFileInfo::UploadCompletionCallback callback =
         upload_file_info->completion_callback;
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_OK, upload_file_info.Pass());
+      callback.Run(DRIVE_FILE_OK, upload_file_info.Pass());
 
     const int kUploadId = 123;
     return kUploadId;
   }
 
   // This function is not mockable by gmock.
   virtual int StreamExistingFile(
       scoped_ptr<UploadFileInfo> upload_file_info) OVERRIDE { return 0; }
 
   MOCK_METHOD6(UploadExistingFile,
@@ skipping 25 matching lines @@
 class GDataFileSystemTest : public testing::Test {
  protected:
   GDataFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(NULL),
         file_system_(NULL),
         mock_drive_service_(NULL),
         mock_webapps_registry_(NULL),
         num_callback_invocations_(0),
-        expected_error_(GDATA_FILE_OK),
+        expected_error_(DRIVE_FILE_OK),
         expected_cache_state_(0),
         expected_sub_dir_type_(DriveCache::CACHE_TYPE_META),
         expected_success_(true),
         expect_outgoing_symlink_(false),
         root_feed_changestamp_(0) {
   }
 
   virtual void SetUp() OVERRIDE {
     chromeos::CrosLibrary::Initialize(true /* use_stub */);
     io_thread_.StartIOThread();
@@ skipping 93 matching lines @@
     ASSERT_TRUE(entry_value->GetAsDictionary(&entry_dict));
 
     // Tweak entry title to match the last segment of the directory path
     // (new directory name).
     std::vector<FilePath::StringType> dir_parts;
     directory_path.GetComponents(&dir_parts);
     entry_dict->SetString("title.$t", dir_parts[dir_parts.size() - 1]);
 
     ASSERT_EQ(file_system_->AddNewDirectory(directory_path.DirName(),
                                             entry_value),
-              GDATA_FILE_OK)
+              DRIVE_FILE_OK)
         << "Failed adding "
         << directory_path.DirName().value();
   }
 
   // Updates the content of directory under |directory_path| with parsed feed
   // |value|.
   bool UpdateContent(const std::vector<DocumentFeed*>& list,
                      int largest_changestamp) {
     GURL unused;
     return file_system_->UpdateFromFeedForTesting(
         list,
         largest_changestamp,
-        root_feed_changestamp_++) == GDATA_FILE_OK;
+        root_feed_changestamp_++) == DRIVE_FILE_OK;
   }
 
   bool RemoveEntry(const FilePath& file_path) {
     return file_system_->RemoveEntryAndCacheLocally(file_path) ==
-        GDATA_FILE_OK;
+        DRIVE_FILE_OK;
   }
 
   FilePath GetCachePathForFile(const std::string& resource_id,
                                const std::string& md5) {
     return cache_->GetCacheFilePath(resource_id,
                                     md5,
                                     DriveCache::CACHE_TYPE_TMP,
                                     DriveCache::CACHED_FILE_FROM_SERVER);
   }
 
@@ skipping 78 matching lines @@
         md5,
         DriveCache::CACHE_TYPE_TMP,
         DriveCache::CACHED_FILE_FROM_SERVER);
     return file_util::PathExists(file_path);
   }
 
   void TestStoreToCache(
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& source_path,
-      GDataFileError expected_error,
+      DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     cache_->StoreOnUIThread(
         resource_id, md5, source_path,
         DriveCache::FILE_OPERATION_COPY,
         base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestPin(
       const std::string& resource_id,
       const std::string& md5,
-      GDataFileError expected_error,
+      DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     cache_->PinOnUIThread(
         resource_id, md5,
         base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestMarkDirty(
       const std::string& resource_id,
       const std::string& md5,
-      GDataFileError expected_error,
+      DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = false;
 
     cache_->MarkDirtyOnUIThread(
         resource_id, md5,
         base::Bind(&GDataFileSystemTest::VerifyMarkDirty,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
-  void VerifyMarkDirty(GDataFileError error,
+  void VerifyMarkDirty(DriveFileError error,
                        const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& cache_file_path) {
     VerifyCacheFileState(error, resource_id, md5);
 
     // Verify filename of |cache_file_path|.
-    if (error == GDATA_FILE_OK) {
+    if (error == DRIVE_FILE_OK) {
       FilePath base_name = cache_file_path.BaseName();
       EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
                 FilePath::kExtensionSeparator +
                 "local",
                 base_name.value());
     } else {
       EXPECT_TRUE(cache_file_path.empty());
     }
   }
 
   void TestCommitDirty(
       const std::string& resource_id,
       const std::string& md5,
-      GDataFileError expected_error,
+      DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = true;
 
     cache_->CommitDirtyOnUIThread(
         resource_id, md5,
         base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   // Verify the file identified by |resource_id| and |md5| is in the expected
   // cache state after |OpenFile|, that is, marked dirty and has no outgoing
   // symlink, etc.
-  void VerifyCacheStateAfterOpenFile(GDataFileError error,
+  void VerifyCacheStateAfterOpenFile(DriveFileError error,
                                      const std::string& resource_id,
                                      const std::string& md5,
                                      const FilePath& cache_file_path) {
-    expected_error_ = GDATA_FILE_OK;
+    expected_error_ = DRIVE_FILE_OK;
     expected_cache_state_ = (test_util::TEST_CACHE_STATE_PRESENT |
                              test_util::TEST_CACHE_STATE_DIRTY |
                              test_util::TEST_CACHE_STATE_PERSISTENT);
     expected_sub_dir_type_ = DriveCache::CACHE_TYPE_PERSISTENT;
     expect_outgoing_symlink_ = false;
     VerifyMarkDirty(error, resource_id, md5, cache_file_path);
   }
 
   // Verify the file identified by |resource_id| and |md5| is in the expected
   // cache state after |CloseFile|, that is, marked dirty and has an outgoing
   // symlink, etc.
-  void VerifyCacheStateAfterCloseFile(GDataFileError error,
+  void VerifyCacheStateAfterCloseFile(DriveFileError error,
                                       const std::string& resource_id,
                                       const std::string& md5) {
-    expected_error_ = GDATA_FILE_OK;
+    expected_error_ = DRIVE_FILE_OK;
     expected_cache_state_ = (test_util::TEST_CACHE_STATE_PRESENT |
                              test_util::TEST_CACHE_STATE_DIRTY |
                              test_util::TEST_CACHE_STATE_PERSISTENT);
     expected_sub_dir_type_ = DriveCache::CACHE_TYPE_PERSISTENT;
     expect_outgoing_symlink_ = true;
     VerifyCacheFileState(error, resource_id, md5);
   }
 
-  void VerifyCacheFileState(GDataFileError error,
+  void VerifyCacheFileState(DriveFileError error,
                             const std::string& resource_id,
                             const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     DriveCacheEntry cache_entry;
     const bool cache_entry_found =
         GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
@@ skipping 180 matching lines @@
     EXPECT_EQ(entry_proto.resource_id(), resource_id);
   }
 
   // This is used as a helper for registering callbacks that need to be
   // RefCountedThreadSafe, and a place where we can fetch results from various
   // operations.
   class CallbackHelper
     : public base::RefCountedThreadSafe<CallbackHelper> {
    public:
     CallbackHelper()
-        : last_error_(GDATA_FILE_OK),
+        : last_error_(DRIVE_FILE_OK),
           quota_bytes_total_(0),
           quota_bytes_used_(0),
           entry_proto_(NULL) {}
 
-    virtual void GetFileCallback(GDataFileError error,
+    virtual void GetFileCallback(DriveFileError error,
                                  const FilePath& file_path,
                                  const std::string& mime_type,
                                  DriveFileType file_type) {
       last_error_ = error;
       download_path_ = file_path;
       mime_type_ = mime_type;
       file_type_ = file_type;
     }
 
-    virtual void FileOperationCallback(GDataFileError error) {
+    virtual void FileOperationCallback(DriveFileError error) {
       DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
       last_error_ = error;
     }
 
-    virtual void GetAvailableSpaceCallback(GDataFileError error,
+    virtual void GetAvailableSpaceCallback(DriveFileError error,
                                            int64 bytes_total,
                                            int64 bytes_used) {
       last_error_ = error;
       quota_bytes_total_ = bytes_total;
       quota_bytes_used_ = bytes_used;
     }
 
-    virtual void OpenFileCallback(GDataFileError error,
+    virtual void OpenFileCallback(DriveFileError error,
                                   const FilePath& file_path) {
       last_error_ = error;
       opened_file_path_ = file_path;
       MessageLoop::current()->Quit();
     }
 
-    virtual void CloseFileCallback(GDataFileError error) {
+    virtual void CloseFileCallback(DriveFileError error) {
       last_error_ = error;
       MessageLoop::current()->Quit();
     }
 
     virtual void GetEntryInfoCallback(
-        GDataFileError error,
+        DriveFileError error,
         scoped_ptr<DriveEntryProto> entry_proto) {
       last_error_ = error;
       entry_proto_ = entry_proto.Pass();
     }
 
     virtual void ReadDirectoryCallback(
-        GDataFileError error,
+        DriveFileError error,
         bool /* hide_hosted_documents */,
         scoped_ptr<DriveEntryProtoVector> entries) {
       last_error_ = error;
       directory_entries_ = entries.Pass();
     }
 
-    GDataFileError last_error_;
+    DriveFileError last_error_;
     FilePath download_path_;
     FilePath opened_file_path_;
     std::string mime_type_;
     DriveFileType file_type_;
     int64 quota_bytes_total_;
     int64 quota_bytes_used_;
     scoped_ptr<DriveEntryProto> entry_proto_;
     scoped_ptr<DriveEntryProtoVector> directory_entries_;
 
    protected:
@@ skipping 14 matching lines @@
   DriveCache* cache_;
   scoped_ptr<StrictMock<MockGDataUploader> > mock_uploader_;
   GDataFileSystem* file_system_;
   StrictMock<MockDriveService>* mock_drive_service_;
   scoped_ptr<StrictMock<MockDriveWebAppsRegistry> > mock_webapps_registry_;
   StrictMock<MockFreeDiskSpaceGetter>* mock_free_disk_space_checker_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int num_callback_invocations_;
-  GDataFileError expected_error_;
+  DriveFileError expected_error_;
   int expected_cache_state_;
   DriveCache::CacheSubDirectoryType expected_sub_dir_type_;
   bool expected_success_;
   bool expect_outgoing_symlink_;
   std::string expected_file_extension_;
   int root_feed_changestamp_;
   static bool cros_initialized_;
 };
 
 bool GDataFileSystemTest::cros_initialized_ = false;
 
 void AsyncInitializationCallback(
     int* counter,
     int expected_counter,
     const FilePath& expected_file_path,
     MessageLoop* message_loop,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
-  ASSERT_EQ(GDATA_FILE_OK, error);
+  ASSERT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entry_proto.get());
   ASSERT_TRUE(entry_proto->file_info().is_directory());
   EXPECT_EQ(expected_file_path.value(), entry_proto->base_name());
 
   (*counter)++;
   if (*counter >= expected_counter)
     message_loop->Quit();
 }
 
 TEST_F(GDataFileSystemTest, DuplicatedAsyncInitialization) {
@@ skipping 387 matching lines @@
 
   // Confirm that the remote file does not exist.
   const FilePath remote_dest_file_path(FILE_PATH_LITERAL("drive/remote.txt"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   // Transfer the local file to Drive.
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   // Prepare a local file, which is a json file of a hosted document, which
   // matches "Document 1" in root_feed.json.
@@ skipping 31 matching lines @@
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Transfer the local file to Drive.
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
   LoadRootFeedDocument("root_feed.json");
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
@@ skipping 28 matching lines @@
               DownloadFile(remote_src_file_path,
                            cache_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path, local_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   std::string cache_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(cache_file, &cache_file_data));
   EXPECT_EQ(remote_src_file_data, cache_file_data);
 
   std::string local_dest_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(local_dest_file_path,
                                           &local_dest_file_data));
   EXPECT_EQ(remote_src_file_data, local_dest_file_data);
 }
 
 TEST_F(GDataFileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath local_dest_file_path = temp_dir.path().Append("local_copy.txt");
   FilePath remote_src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path, local_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   scoped_ptr<DriveEntryProto> entry_proto = GetEntryInfoByPathSync(
       remote_src_file_path);
   ASSERT_TRUE(entry_proto.get());
   VerifyHostedDocumentJSONFile(*entry_proto, local_dest_file_path);
 }
 
 TEST_F(GDataFileSystemTest, CopyNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Copy(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, CopyFileToNonExistingDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_path_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is an existing file,
 // not a directory.
 TEST_F(GDataFileSystemTest, CopyFileToInvalidPath) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
@@ skipping 15 matching lines @@
   scoped_ptr<DriveEntryProto> dest_entry_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_entry_proto.get());
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Copy(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_A_DIRECTORY,
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY,
             callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
 
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, RenameFile) {
@@ skipping 18 matching lines @@
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileFromRootToSubDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
@@ skipping 28 matching lines @@
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileFromSubDirectoryToRoot) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
@@ skipping 30 matching lines @@
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   ASSERT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileBetweenSubDirectories) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
@@ skipping 54 matching lines @@
   // interim file path.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/New Folder 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(interim_file_path));
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileToNonExistingDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is a existing file,
 // not a directory.
 TEST_F(GDataFileSystemTest, MoveFileToInvalidPath) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
@@ skipping 15 matching lines @@
   scoped_ptr<DriveEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_A_DIRECTORY,
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY,
             callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, RemoveEntries) {
   LoadRootFeedDocument("root_feed.json");
 
@@ skipping 128 matching lines @@
 
 // Create a directory through the document service
 TEST_F(GDataFileSystemTest, CreateDirectoryWithService) {
   LoadRootFeedDocument("root_feed.json");
   EXPECT_CALL(*mock_drive_service_,
               CreateDirectory(_, "Sample Directory Title", _)).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   // Set last error so it's not a valid error code.
-  callback_helper_->last_error_ = static_cast<GDataFileError>(1);
+  callback_helper_->last_error_ = static_cast<DriveFileError>(1);
   file_system_->CreateDirectory(
       FilePath(FILE_PATH_LITERAL("drive/Sample Directory Title")),
       false,  // is_exclusive
       true,  // is_recursive
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get()));
   test_util::RunBlockingPoolTask();
   // TODO(gspencer): Uncomment this when we get a blob that
   // works that can be returned from the mock.
-  // EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  // EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
@@ skipping 17 matching lines @@
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
@@ skipping 19 matching lines @@
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(0);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_ERROR_NO_SPACE,
+  EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE,
             callback_helper_->last_error_);
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
@@ skipping 10 matching lines @@
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(0))
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(file_size + kMinFreeSpace));
 
   // Store something in the temporary cache directory.
   TestStoreToCache("<resource_id>",
                    "<md5>",
                    GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK,
+                   DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   ASSERT_TRUE(CacheEntryExists("<resource_id>", "<md5>"));
   ASSERT_TRUE(CacheFileExists("<resource_id>", "<md5>"));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService, because of we freed up the
   // space.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 
   // The file should be removed in order to free up space, and the cache
   // entry should also be removed.
   ASSERT_FALSE(CacheEntryExists("<resource_id>", "<md5>"));
   ASSERT_FALSE(CacheFileExists("<resource_id>", "<md5>"));
 }
 
@@ skipping 30 matching lines @@
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_ERROR_NO_SPACE,
+  EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE,
             callback_helper_->last_error_);
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
                    GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK,
+                   DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Make sure we don't fetch metadata for downloading file.
   EXPECT_CALL(*mock_drive_service_, GetDocumentEntry(_, _)).Times(0);
 
   // Make sure we don't call downloads at all.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
@@ skipping 87 matching lines @@
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
                    GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK,
+                   DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // The file is obtained from the cache.
   // Make sure we don't call downloads at all.
   EXPECT_CALL(*mock_drive_service_, DownloadFile(_, _, _, _, _))
       .Times(0);
 
   file_system_->GetFileByResourceId(entry_proto->resource_id(),
                                     callback,
@@ skipping 13 matching lines @@
 
   // This is a file defined in root_feed.json.
   const FilePath kFilePath(FILE_PATH_LITERAL("drive/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
   const std::string kMd5("3b4382ebefec6e743578c76bbd0575ce");
 
   // Pin the file so it'll be store in "persistent" directory.
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(kResourceId, kMd5)).Times(1);
   TestPin(kResourceId,
           kMd5,
-          GDATA_FILE_OK,
+          DRIVE_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           DriveCache::CACHE_TYPE_TMP);
 
   // First store a file to cache. A cache file will be created at:
   // GCache/v1/persistent/<kResourceId>.<kMd5>
   const FilePath original_cache_file_path =
       DriveCache::GetCacheRootPath(profile_.get())
       .AppendASCII("persistent")
       .AppendASCII(kResourceId + "." + kMd5);
   TestStoreToCache(kResourceId,
                    kMd5,
                    GetTestFilePath("root_feed.json"),  // Anything works.
-                   GDATA_FILE_OK,
+                   DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_PINNED |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    DriveCache::CACHE_TYPE_PERSISTENT);
   ASSERT_TRUE(file_util::PathExists(original_cache_file_path));
 
   // Add the dirty bit. The cache file will be renamed to
   // GCache/v1/persistent/<kResourceId>.local
   TestMarkDirty(kResourceId,
                 kMd5,
-                GDATA_FILE_OK,
+                DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_PINNED |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   const FilePath dirty_cache_file_path =
       DriveCache::GetCacheRootPath(profile_.get())
       .AppendASCII("persistent")
       .AppendASCII(kResourceId + ".local");
   ASSERT_FALSE(file_util::PathExists(original_cache_file_path));
   ASSERT_TRUE(file_util::PathExists(dirty_cache_file_path));
 
   // Modify the cached file.
   const std::string kDummyCacheContent("modification to the cache");
   ASSERT_TRUE(file_util::WriteFile(dirty_cache_file_path,
                                    kDummyCacheContent.c_str(),
                                    kDummyCacheContent.size()));
 
   // Commit the dirty bit. The cache file name remains the same
   // but a symlink will be created at:
   // GCache/v1/outgoing/<kResourceId>
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(kResourceId)).Times(1);
   TestCommitDirty(kResourceId,
                   kMd5,
-                  GDATA_FILE_OK,
+                  DRIVE_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_PINNED |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   const FilePath outgoing_symlink_path =
       DriveCache::GetCacheRootPath(profile_.get())
       .AppendASCII("outgoing")
       .AppendASCII(kResourceId);
   ASSERT_TRUE(file_util::PathExists(dirty_cache_file_path));
@@ skipping 24 matching lines @@
 
   // The mock uploader will be used to simulate a file upload.
   EXPECT_CALL(*mock_uploader_, UploadExistingFile(
       GURL("https://file_link_resumable_edit_media/"),
       kFilePath,
       dirty_cache_file_path,
       kDummyCacheContent.size(),  // The size after modification must be used.
       "audio/mpeg",
       _))  // callback
       .WillOnce(MockUploadExistingFile(
-          GDATA_FILE_OK,
+          DRIVE_FILE_OK,
           FilePath::FromUTF8Unsafe("drive/File1"),
           dirty_cache_file_path,
           document_entry));
 
   // We'll notify the directory change to the observer upon completion.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kDriveRootDirectory)))).Times(1);
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Check the number of files in the root directory. We'll compare the
   // number after updating a file.
   scoped_ptr<DriveEntryProtoVector> root_directory_entries(
       ReadDirectoryByPathSync(FilePath::FromUTF8Unsafe("drive")));
   ASSERT_TRUE(root_directory_entries.get());
   const int num_files_in_root = CountFiles(*root_directory_entries);
 
   file_system_->UpdateFileByResourceId(kResourceId, callback);
   test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
   // Make sure that the number of files did not change (i.e. we updated an
   // existing file, rather than adding a new file. The number of files
   // increases if we don't handle the file update right).
   EXPECT_EQ(num_files_in_root, CountFiles(*root_directory_entries));
   // After the file is updated, the dirty bit is cleared, hence the symlink
   // should be gone.
   ASSERT_FALSE(file_util::PathExists(outgoing_symlink_path));
 }
 
 TEST_F(GDataFileSystemTest, UpdateFileByResourceId_NonexistentFile) {
   LoadRootFeedDocument("root_feed.json");
 
   // This is nonexistent in root_feed.json.
   const FilePath kFilePath(FILE_PATH_LITERAL("drive/Nonexistent.txt"));
   const std::string kResourceId("file:nonexistent_resource_id");
   const std::string kMd5("nonexistent_md5");
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->UpdateFileByResourceId(kResourceId, callback);
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 TEST_F(GDataFileSystemTest, ContentSearch) {
   LoadRootFeedDocument("root_feed.json");
 
   mock_drive_service_->set_search_result("search_result_feed.json");
 
   EXPECT_CALL(*mock_drive_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
       .Times(1);
 
@@ skipping 130 matching lines @@
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   // Open kFileInRoot ("drive/File 1.txt").
   file_system_->OpenFile(kFileInRoot, callback);
   message_loop_.Run();
   const FilePath opened_file_path = callback_helper_->opened_file_path_;
 
   // Verify that the file was properly opened.
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Try to open the already opened file.
   file_system_->OpenFile(kFileInRoot, callback);
   message_loop_.Run();
 
   // It must fail.
-  EXPECT_EQ(GDATA_FILE_ERROR_IN_USE, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_IN_USE, callback_helper_->last_error_);
 
   // Verify that the file contents match the expected contents.
   std::string cache_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(opened_file_path, &cache_file_data));
   EXPECT_EQ(kExpectedFileData, cache_file_data);
 
   // Verify that the cache state was changed as expected.
-  VerifyCacheStateAfterOpenFile(GDATA_FILE_OK,
+  VerifyCacheStateAfterOpenFile(DRIVE_FILE_OK,
                                 file_resource_id,
                                 file_md5,
                                 opened_file_path);
 
   // Close kFileInRoot ("drive/File 1.txt").
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // Verify that the file was properly closed.
-  EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Verify that the cache state was changed as expected.
-  VerifyCacheStateAfterCloseFile(GDATA_FILE_OK,
+  VerifyCacheStateAfterCloseFile(DRIVE_FILE_OK,
                                  file_resource_id,
                                  file_md5);
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
-  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata