Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/drive_cache_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 <algorithm>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 97 matching lines @@
   *out_to_upload = to_upload;
 }
 
 // Copies results from GetResourceIdsCallback.
 void OnGetResourceIds(std::vector<std::string>* out_resource_ids,
                       const std::vector<std::string>& resource_ids) {
   *out_resource_ids = resource_ids;
 }
 
 // Copies results from ClearAllOnUIThread.
-void OnClearAll(GDataFileError* out_error,
+void OnClearAll(DriveFileError* out_error,
                 FilePath* out_file_path,
-                GDataFileError error,
+                DriveFileError error,
                 const FilePath& file_path) {
   *out_file_path = file_path;
   *out_error = error;
 }
 
 }  // namespace
 
 class DriveCacheTest : public testing::Test {
  protected:
   DriveCacheTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(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 {
     io_thread_.StartIOThread();
 
@@ skipping 95 matching lines @@
 
   void TestInitializeCache() {
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(initial_cache_resources); ++i) {
       const struct InitialCacheResource& resource = initial_cache_resources[i];
       // Check cache file.
       num_callback_invocations_ = 0;
       TestGetFileFromCacheByResourceIdAndMd5(
           resource.resource_id,
           resource.md5,
           test_util::ToCacheEntry(resource.cache_state).is_present() ?
-          GDATA_FILE_OK :
-          GDATA_FILE_ERROR_NOT_FOUND,
+          DRIVE_FILE_OK :
+          DRIVE_FILE_ERROR_NOT_FOUND,
           resource.expected_file_extension);
       EXPECT_EQ(1, num_callback_invocations_);
 
       // Verify cache state.
       std::string md5;
       if (test_util::ToCacheEntry(resource.cache_state).is_present())
          md5 = resource.md5;
       DriveCacheEntry cache_entry;
       ASSERT_TRUE(GetCacheEntryFromOriginThread(
           resource.resource_id, md5, &cache_entry));
       EXPECT_TRUE(test_util::CacheStatesEqual(
           test_util::ToCacheEntry(resource.cache_state),
           cache_entry));
       EXPECT_EQ(resource.expected_sub_dir_type,
                 DriveCache::GetSubDirectoryType(cache_entry));
     }
   }
 
   void TestGetFileFromCacheByResourceIdAndMd5(
       const std::string& resource_id,
       const std::string& md5,
-      GDataFileError expected_error,
+      DriveFileError expected_error,
       const std::string& expected_file_extension) {
     expected_error_ = expected_error;
     expected_file_extension_ = expected_file_extension;
 
     cache_->GetFileOnUIThread(
         resource_id, md5,
         base::Bind(&DriveCacheTest::VerifyGetFromCache,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   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(&DriveCacheTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
-  void VerifyGetFromCache(GDataFileError error,
+  void VerifyGetFromCache(DriveFileError error,
                           const std::string& resource_id,
                           const std::string& md5,
                           const FilePath& cache_file_path) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
-    if (error == GDATA_FILE_OK) {
+    if (error == DRIVE_FILE_OK) {
       // Verify filename of |cache_file_path|.
       FilePath base_name = cache_file_path.BaseName();
       EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
                 FilePath::kExtensionSeparator +
                 util::EscapeCacheFileName(
                     expected_file_extension_.empty() ?
                     md5 : expected_file_extension_),
                 base_name.value());
     } else {
       EXPECT_TRUE(cache_file_path.empty());
     }
   }
 
   void TestRemoveFromCache(const std::string& resource_id,
-                           GDataFileError expected_error) {
+                           DriveFileError expected_error) {
     expected_error_ = expected_error;
 
     cache_->RemoveOnUIThread(
         resource_id,
         base::Bind(&DriveCacheTest::VerifyRemoveFromCache,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
-  void VerifyRemoveFromCache(GDataFileError error,
+  void VerifyRemoveFromCache(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 77 matching lines @@
           EXPECT_EQ(0U, num_files_found);
         else
           EXPECT_EQ(1U, num_files_found);
       }
     }
   }
 
   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(&DriveCacheTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestUnpin(
       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_->UnpinOnUIThread(
         resource_id, md5,
         base::Bind(&DriveCacheTest::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(&DriveCacheTest::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(&DriveCacheTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestClearDirty(
       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_->ClearDirtyOnUIThread(resource_id, md5,
         base::Bind(&DriveCacheTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestSetMountedState(
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& file_path,
       bool to_mount,
-      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_->SetMountedStateOnUIThread(file_path, to_mount,
         base::Bind(&DriveCacheTest::VerifySetMountedState,
                    base::Unretained(this), resource_id, md5, to_mount));
 
     test_util::RunBlockingPoolTask();
   }
 
   void VerifySetMountedState(const std::string& resource_id,
                              const std::string& md5,
                              bool to_mount,
-                             GDataFileError error,
+                             DriveFileError error,
                              const FilePath& file_path) {
     ++num_callback_invocations_;
     EXPECT_TRUE(file_util::PathExists(file_path));
     EXPECT_TRUE(file_path == cache_->GetCacheFilePath(
         resource_id,
         md5,
         expected_sub_dir_type_,
         to_mount ?
             DriveCache::CACHED_FILE_MOUNTED :
             DriveCache::CACHED_FILE_FROM_SERVER));
   }
 
-  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 174 matching lines @@
   // See also content/browser/browser_thread_imple.cc.
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
   DriveCache* cache_;
   MockFreeDiskSpaceGetter* mock_free_disk_space_checker_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_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_;
 };
 
 TEST_F(DriveCacheTest, InitializeCache) {
   PrepareForInitCacheTest();
@@ skipping 23 matching lines @@
 
 TEST_F(DriveCacheTest, StoreToCacheSimple) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a non-existent file to the same |resource_id| and |md5|.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
-                   GDATA_FILE_ERROR_FAILED,
+                   DRIVE_FILE_ERROR_FAILED,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a different existing file to the same |resource_id| but different
   // |md5|.
   md5 = "new_md5";
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's only one file with name <resource_id>, i.e. previously
   // cached file with the different md5 should be deleted.
   EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 }
 
 TEST_F(DriveCacheTest, GetFromCacheSimple) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Then try to get the existing file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
-      resource_id, md5, GDATA_FILE_OK, md5);
+      resource_id, md5, DRIVE_FILE_OK, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Get file from cache with same resource id as existing file but different
   // md5.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
-      resource_id, "9999", GDATA_FILE_ERROR_NOT_FOUND, md5);
+      resource_id, "9999", DRIVE_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Get file from cache with different resource id from existing file but same
   // md5.
   num_callback_invocations_ = 0;
   resource_id = "document:1a2b";
   TestGetFileFromCacheByResourceIdAndMd5(
-      resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND, md5);
+      resource_id, md5, DRIVE_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, RemoveFromCacheSimple) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   // Use alphanumeric characters for resource id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Then try to remove existing file from cache.
   num_callback_invocations_ = 0;
-  TestRemoveFromCache(resource_id, GDATA_FILE_OK);
+  TestRemoveFromCache(resource_id, DRIVE_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Repeat using non-alphanumeric characters for resource id, including '.'
   // which is an extension separator.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   num_callback_invocations_ = 0;
-  TestRemoveFromCache(resource_id, GDATA_FILE_OK);
+  TestRemoveFromCache(resource_id, DRIVE_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, PinAndUnpin) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(2);
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(1);
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Pin the existing file in cache.
   num_callback_invocations_ = 0;
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, 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);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Unpin the existing file in cache.
   num_callback_invocations_ = 0;
-  TestUnpin(resource_id, md5, GDATA_FILE_OK,
+  TestUnpin(resource_id, md5, DRIVE_FILE_OK,
             test_util::TEST_CACHE_STATE_PRESENT,
             DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Pin back the same existing file in cache.
   num_callback_invocations_ = 0;
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, 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);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Pin a non-existent file in cache.
   resource_id = "document:1a2b";
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(1);
 
   num_callback_invocations_ = 0;
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, DRIVE_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Unpin the previously pinned non-existent file in cache.
   num_callback_invocations_ = 0;
-  TestUnpin(resource_id, md5, GDATA_FILE_OK,
+  TestUnpin(resource_id, md5, DRIVE_FILE_OK,
             test_util::TEST_CACHE_STATE_NONE,
             DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Unpin a file that doesn't exist in cache and is not pinned, i.e. cache
   // has zero knowledge of the file.
   resource_id = "not-in-cache:1a2b";
   // Because unpinning will fail, OnCacheUnpinned() won't be run.
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(0);
 
   num_callback_invocations_ = 0;
-  TestUnpin(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
+  TestUnpin(resource_id, md5, DRIVE_FILE_ERROR_NOT_FOUND,
             test_util::TEST_CACHE_STATE_NONE,
             DriveCache::CACHE_TYPE_TMP /* non-applicable */);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, StoreToCachePinned) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, DRIVE_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           DriveCache::CACHE_TYPE_TMP);
 
   // Store an existing file to a previously pinned file.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   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);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a non-existent file to a previously pinned and stored file.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
-                   GDATA_FILE_ERROR_FAILED,
+                   DRIVE_FILE_ERROR_FAILED,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_PINNED |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, GetFromCachePinned) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, DRIVE_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           DriveCache::CACHE_TYPE_TMP);
 
   // Get the non-existent pinned file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
-      resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND, md5);
+      resource_id, md5, DRIVE_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store an existing file to the previously pinned non-existent file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   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);
 
   // Get the previously pinned and stored file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
-      resource_id, md5, GDATA_FILE_OK, md5);
+      resource_id, md5, DRIVE_FILE_OK, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, RemoveFromCachePinned) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   // Use alphanumeric characters for resource_id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Store a file to cache, and pin it.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, 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);
 
   // Remove |resource_id| from cache.
   num_callback_invocations_ = 0;
-  TestRemoveFromCache(resource_id, GDATA_FILE_OK);
+  TestRemoveFromCache(resource_id, DRIVE_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Repeat using non-alphanumeric characters for resource id, including '.'
   // which is an extension separator.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, 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);
 
   num_callback_invocations_ = 0;
-  TestRemoveFromCache(resource_id, GDATA_FILE_OK);
+  TestRemoveFromCache(resource_id, DRIVE_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, DirtyCacheSimple) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Mark the file dirty.
   num_callback_invocations_ = 0;
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
-  TestClearDirty(resource_id, md5, GDATA_FILE_OK,
+  TestClearDirty(resource_id, md5, DRIVE_FILE_OK,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, DirtyCachePinned) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
 
   // First store a file to cache and pin it.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, 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);
 
   // Mark the file dirty.
   num_callback_invocations_ = 0;
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PINNED |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PINNED |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
-  TestClearDirty(resource_id, md5, GDATA_FILE_OK,
+  TestClearDirty(resource_id, md5, 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);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 // Test is disabled because it is flaky (http://crbug.com/134146)
 TEST_F(DriveCacheTest, PinAndUnpinDirtyCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(1);
 
   // First store a file to cache and mark it as dirty.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
 
   // Verifies dirty file exists.
   FilePath dirty_path = GetCacheFilePath(
       resource_id,
       md5,
       DriveCache::CACHE_TYPE_PERSISTENT,
       DriveCache::CACHED_FILE_LOCALLY_MODIFIED);
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 
   // Pin the dirty file.
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, DRIVE_FILE_OK,
           test_util::TEST_CACHE_STATE_PRESENT |
           test_util::TEST_CACHE_STATE_DIRTY |
           test_util::TEST_CACHE_STATE_PINNED |
           test_util::TEST_CACHE_STATE_PERSISTENT,
           DriveCache::CACHE_TYPE_PERSISTENT);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 
   // Unpin the dirty file.
-  TestUnpin(resource_id, md5, GDATA_FILE_OK,
+  TestUnpin(resource_id, md5, DRIVE_FILE_OK,
             test_util::TEST_CACHE_STATE_PRESENT |
             test_util::TEST_CACHE_STATE_DIRTY |
             test_util::TEST_CACHE_STATE_PERSISTENT,
             DriveCache::CACHE_TYPE_PERSISTENT);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 }
 
 TEST_F(DriveCacheTest, DirtyCacheRepetitive) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(3);
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Mark the file dirty.
   num_callback_invocations_ = 0;
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Again, mark the file dirty.  Nothing should change.
   num_callback_invocations_ = 0;
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.  Outgoing symlink should be created.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Again, commit the file dirty.  Nothing should change.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Mark the file dirty agian after it's being committed.  Outgoing symlink
   // should be deleted.
   num_callback_invocations_ = 0;
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.  Outgoing symlink should be created again.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
-  TestClearDirty(resource_id, md5, GDATA_FILE_OK,
+  TestClearDirty(resource_id, md5, DRIVE_FILE_OK,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Again, clear dirty state of the file, which is no longer dirty.
   num_callback_invocations_ = 0;
-  TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
+  TestClearDirty(resource_id, md5, DRIVE_FILE_ERROR_INVALID_OPERATION,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, DirtyCacheInvalid) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Mark a non-existent file dirty.
   num_callback_invocations_ = 0;
-  TestMarkDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_ERROR_NOT_FOUND,
                 test_util::TEST_CACHE_STATE_NONE,
                 DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit a non-existent file dirty.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_ERROR_NOT_FOUND,
                   test_util::TEST_CACHE_STATE_NONE,
                   DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of a non-existent file.
   num_callback_invocations_ = 0;
-  TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
+  TestClearDirty(resource_id, md5, DRIVE_FILE_ERROR_NOT_FOUND,
                  test_util::TEST_CACHE_STATE_NONE,
                  DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Commit a non-dirty existing file dirty.
   num_callback_invocations_ = 0;
-  TestCommitDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
+  TestCommitDirty(resource_id, md5, DRIVE_FILE_ERROR_INVALID_OPERATION,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of a non-dirty existing file.
   num_callback_invocations_ = 0;
-  TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
+  TestClearDirty(resource_id, md5, DRIVE_FILE_ERROR_INVALID_OPERATION,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Mark an existing file dirty, then store a new file to the same resource id
   // but different md5, which should fail.
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 DriveCache::CACHE_TYPE_PERSISTENT);
   num_callback_invocations_ = 0;
   md5 = "new_md5";
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
-                   GDATA_FILE_ERROR_IN_USE,
+                   DRIVE_FILE_ERROR_IN_USE,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_DIRTY |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, RemoveFromDirtyCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
 
   // Store a file to cache, pin it, mark it dirty and commit it.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
-  TestPin(resource_id, md5, GDATA_FILE_OK,
+  TestPin(resource_id, md5, 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);
-  TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
+  TestMarkDirty(resource_id, md5, 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);
-  TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
+  TestCommitDirty(resource_id, md5, 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);
 
   // Try to remove the file.  Since file is dirty, it and the corresponding
   // pinned and outgoing symlinks should not be removed.
   num_callback_invocations_ = 0;
-  TestRemoveFromCache(resource_id, GDATA_FILE_OK);
+  TestRemoveFromCache(resource_id, DRIVE_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, MountUnmount) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   FilePath file_path;
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // First store a file to cache in the tmp subdir.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Mark the file mounted.
   num_callback_invocations_ = 0;
   file_path = cache_->GetCacheFilePath(resource_id, md5,
                                        DriveCache::CACHE_TYPE_TMP,
                                        DriveCache::CACHED_FILE_FROM_SERVER);
   TestSetMountedState(resource_id, md5, file_path, true,
-                      GDATA_FILE_OK,
+                      DRIVE_FILE_OK,
                       test_util::TEST_CACHE_STATE_PRESENT |
                       test_util::TEST_CACHE_STATE_MOUNTED |
                       test_util::TEST_CACHE_STATE_PERSISTENT,
                       DriveCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Clear mounted state of the file.
   num_callback_invocations_ = 0;
   file_path = cache_->GetCacheFilePath(resource_id,
                                        md5,
                                        DriveCache::CACHE_TYPE_PERSISTENT,
                                        DriveCache::CACHED_FILE_MOUNTED);
   TestSetMountedState(resource_id, md5, file_path, false,
-                      GDATA_FILE_OK,
+                      DRIVE_FILE_OK,
                       test_util::TEST_CACHE_STATE_PRESENT,
                       DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   num_callback_invocations_ = 0;
-  TestRemoveFromCache(resource_id, GDATA_FILE_OK);
+  TestRemoveFromCache(resource_id, DRIVE_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(DriveCacheTest, GetResourceIdsOfBacklogOnUIThread) {
   PrepareForInitCacheTest();
 
   std::vector<std::string> to_fetch;
   std::vector<std::string> to_upload;
   cache_->GetResourceIdsOfBacklogOnUIThread(
       base::Bind(&OnGetResourceIdsOfBacklog, &to_fetch, &to_upload));
@@ skipping 46 matching lines @@
   PrepareForInitCacheTest();
 
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's only one cached file.
   EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 
   // Clear cache.
-  GDataFileError error = GDATA_FILE_OK;
+  DriveFileError error = DRIVE_FILE_OK;
   FilePath file_path;
   cache_->ClearAllOnUIThread(base::Bind(&OnClearAll,
                                         &error,
                                         &file_path));
   test_util::RunBlockingPoolTask();
-  EXPECT_EQ(GDATA_FILE_OK, error);
+  EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Verify that all the cache is removed.
   VerifyRemoveFromCache(error, resource_id, md5);
   EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
 }
 
 TEST_F(DriveCacheTest, StoreToCacheNoSpace) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(0));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Try to store an existing file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   GDATA_FILE_ERROR_NO_SPACE,
+                   DRIVE_FILE_ERROR_NO_SPACE,
                    test_util::TEST_CACHE_STATE_NONE,
                    DriveCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's no files added.
   EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
 }
 
 
 }   // namespace gdata