drive: Rename 'gdata' namespace to 'drive' in chrome/browser/chromeos/drive

chrome/browser/chromeos/drive/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 "chrome/browser/chromeos/drive/drive_cache.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_test_util.h"
 #include "chrome/browser/chromeos/drive/mock_drive_cache_observer.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AtLeast;
 using ::testing::Return;
 using ::testing::StrictMock;
 
-namespace gdata {
+namespace drive {
 namespace {
 
 const char kSymLinkToDevNull[] = "/dev/null";
 
 struct InitialCacheResource {
   const char* source_file;              // Source file to be used for cache.
   const char* resource_id;              // Resource id of cache file.
   const char* md5;                      // MD5 of cache file.
   int cache_state;                      // Cache state of cache file.
   const char* expected_file_extension;  // Expected extension of cached file.
@@ skipping 116 matching lines @@
     cache_ = DriveCache::CreateDriveCacheOnUIThread(
         DriveCache::GetCacheRootPath(profile_.get()), blocking_task_runner_);
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     bool initialization_success = false;
     cache_->RequestInitializeOnUIThread(
         base::Bind(&test_util::CopyResultFromInitializeCacheCallback,
                    &initialization_success));
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
     ASSERT_TRUE(initialization_success);
   }
 
   virtual void TearDown() OVERRIDE {
     SetFreeDiskSpaceGetterForTesting(NULL);
     cache_->DestroyOnUIThread();
     // The cache destruction requires to post a task to the blocking pool.
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
 
     profile_.reset(NULL);
   }
 
   void PrepareForInitCacheTest() {
     DVLOG(1) << "PrepareForInitCacheTest start";
     // Create drive cache sub directories.
     ASSERT_TRUE(file_util::CreateDirectory(
         cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_PERSISTENT)));
     ASSERT_TRUE(file_util::CreateDirectory(
@@ skipping 18 matching lines @@
           test_util::ToCacheEntry(resource.cache_state).is_dirty() ?
                   DriveCache::CACHE_TYPE_PERSISTENT :
                   DriveCache::CACHE_TYPE_TMP,
           test_util::ToCacheEntry(resource.cache_state).is_dirty() ?
               DriveCache::CACHED_FILE_LOCALLY_MODIFIED :
               DriveCache::CACHED_FILE_FROM_SERVER);
 
       // Copy file from data dir to cache subdir, naming it per cache files
       // convention.
       if (test_util::ToCacheEntry(resource.cache_state).is_present()) {
-        FilePath source_path = test_util::GetTestFilePath(resource.source_file);
+        FilePath source_path =
+            gdata::test_util::GetTestFilePath(resource.source_file);
         ASSERT_TRUE(file_util::CopyFile(source_path, dest_path));
       } else {
         dest_path = FilePath(FILE_PATH_LITERAL(kSymLinkToDevNull));
       }
 
       // Create symbolic link in pinned dir, naming it per cache files
       // convention.
       if (test_util::ToCacheEntry(resource.cache_state).is_pinned()) {
         FilePath link_path = cache_->GetCacheFilePath(
             resource.resource_id,
@@ skipping 10 matching lines @@
             resource.resource_id,
             "",
             DriveCache::CACHE_TYPE_OUTGOING,
             DriveCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
     }
 
     DVLOG(1) << "PrepareForInitCacheTest finished";
     cache_->ForceRescanOnUIThreadForTesting();
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   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,
@@ skipping 27 matching lines @@
     expected_file_extension_ = expected_file_extension;
 
     cache_->GetFileOnUIThread(
         resource_id,
         md5,
         base::Bind(&DriveCacheTest::VerifyGetFromCache,
                    base::Unretained(this),
                    resource_id,
                    md5));
 
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void TestStoreToCache(
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& source_path,
       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();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void VerifyGetFromCache(const std::string& resource_id,
                           const std::string& md5,
                           DriveFileError error,
                           const FilePath& cache_file_path) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
@@ skipping 13 matching lines @@
 
   void TestRemoveFromCache(const std::string& resource_id,
                            DriveFileError expected_error) {
     expected_error_ = expected_error;
 
     cache_->RemoveOnUIThread(
         resource_id,
         base::Bind(&DriveCacheTest::VerifyRemoveFromCache,
                    base::Unretained(this)));
 
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void VerifyRemoveFromCache(DriveFileError error,
                              const std::string& resource_id,
                              const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
@@ skipping 92 matching lines @@
       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();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void TestUnpin(
       const std::string& resource_id,
       const std::string& md5,
       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();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void TestMarkDirty(
       const std::string& resource_id,
       const std::string& md5,
       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),
                    resource_id,
                    md5));
 
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void VerifyMarkDirty(const std::string& resource_id,
                        const std::string& md5,
                        DriveFileError error,
                        const FilePath& cache_file_path) {
     VerifyCacheFileState(error, resource_id, md5);
 
     // Verify filename of |cache_file_path|.
     if (error == DRIVE_FILE_OK) {
@@ skipping 16 matching lines @@
     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();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void TestClearDirty(
       const std::string& resource_id,
       const std::string& md5,
       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();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void TestSetMountedState(
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& file_path,
       bool to_mount,
       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();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void VerifySetMountedState(const std::string& resource_id,
                              const std::string& md5,
                              bool to_mount,
                              DriveFileError error,
                              const FilePath& file_path) {
     ++num_callback_invocations_;
     EXPECT_TRUE(file_util::PathExists(file_path));
     EXPECT_TRUE(file_path == cache_->GetCacheFilePath(
@@ skipping 100 matching lines @@
                                      DriveCacheEntry* cache_entry) {
     bool result = false;
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DriveCacheTest::GetCacheEntryFromOriginThreadInternal,
                    base::Unretained(this),
                    resource_id,
                    md5,
                    cache_entry,
                    &result));
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
     return result;
   }
 
   // Used to implement GetCacheEntry.
   void GetCacheEntryFromOriginThreadInternal(
       const std::string& resource_id,
       const std::string& md5,
       DriveCacheEntry* cache_entry,
       bool* result) {
     *result = cache_->GetCacheEntry(resource_id, md5, cache_entry);
@@ skipping 104 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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"),
                    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,
-                   test_util::GetTestFilePath("gdata/subdir_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/subdir_feed.json"),
                    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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, DRIVE_FILE_OK, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Get file from cache with same resource id as existing file but different
@@ skipping 14 matching lines @@
 
 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   num_callback_invocations_ = 0;
   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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, 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);
@@ skipping 57 matching lines @@
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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"),
@@ skipping 19 matching lines @@
           DriveCache::CACHE_TYPE_TMP);
 
   // Get the non-existent pinned file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
       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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   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, 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   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, 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, 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);
@@ skipping 20 matching lines @@
   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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   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;
@@ skipping 31 matching lines @@
       .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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   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(
@@ skipping 28 matching lines @@
 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, 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);
@@ skipping 83 matching lines @@
 
   // Clear dirty state of a non-existent file.
   num_callback_invocations_ = 0;
   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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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, 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, 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, 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,
-                   test_util::GetTestFilePath("gdata/subdir_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/subdir_feed.json"),
                    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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    DRIVE_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   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, DRIVE_FILE_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_PINNED |
@@ skipping 17 matching lines @@
 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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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,
                       DRIVE_FILE_OK,
@@ skipping 23 matching lines @@
   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));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 
   sort(to_fetch.begin(), to_fetch.end());
   ASSERT_EQ(1U, to_fetch.size());
   EXPECT_EQ("pinned:non-existent", to_fetch[0]);
 
   sort(to_upload.begin(), to_upload.end());
   ASSERT_EQ(2U, to_upload.size());
   EXPECT_EQ("dirty:existing", to_upload[0]);
   EXPECT_EQ("dirty_and_pinned:existing", to_upload[1]);
 }
 
 TEST_F(DriveCacheTest, GetResourceIdsOfExistingPinnedFilesOnUIThread) {
   PrepareForInitCacheTest();
 
   std::vector<std::string> resource_ids;
   cache_->GetResourceIdsOfExistingPinnedFilesOnUIThread(
       base::Bind(&OnGetResourceIds, &resource_ids));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 
   sort(resource_ids.begin(), resource_ids.end());
   ASSERT_EQ(2U, resource_ids.size());
   EXPECT_EQ("dirty_and_pinned:existing", resource_ids[0]);
   EXPECT_EQ("pinned:existing", resource_ids[1]);
 }
 
 TEST_F(DriveCacheTest, GetResourceIdsOfAllFilesOnUIThread) {
   PrepareForInitCacheTest();
 
   std::vector<std::string> resource_ids;
   cache_->GetResourceIdsOfAllFilesOnUIThread(
       base::Bind(&OnGetResourceIds, &resource_ids));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 
   sort(resource_ids.begin(), resource_ids.end());
   ASSERT_EQ(6U, resource_ids.size());
   EXPECT_EQ("dirty:existing", resource_ids[0]);
   EXPECT_EQ("dirty_and_pinned:existing", resource_ids[1]);
   EXPECT_EQ("pinned:existing", resource_ids[2]);
   EXPECT_EQ("pinned:non-existent", resource_ids[3]);
   EXPECT_EQ("tmp:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?", resource_ids[4]);
   EXPECT_EQ("tmp:resource_id", resource_ids[5]);
 }
 
 
 TEST_F(DriveCacheTest, ClearAllOnUIThread) {
   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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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.
   DriveFileError error = DRIVE_FILE_OK;
   FilePath file_path;
   cache_->ClearAllOnUIThread(base::Bind(&OnClearAll,
                                         &error,
                                         &file_path));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   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,
-                   test_util::GetTestFilePath("gdata/root_feed.json"),
+                   gdata::test_util::GetTestFilePath("gdata/root_feed.json"),
                    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));
 }
 
 // Don't use TEST_F, as we don't want SetUp() and TearDown() for this test.
 TEST(DriveCacheExtraTest, InitializationFailure) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
 
   scoped_refptr<base::SequencedWorkerPool> pool =
       content::BrowserThread::GetBlockingPool();
 
   // Set the cache root to a non existent path, so the initialization fails.
   DriveCache* cache = DriveCache::CreateDriveCacheOnUIThread(
       FilePath::FromUTF8Unsafe("/somewhere/nonexistent/blah/blah"),
       pool->GetSequencedTaskRunner(pool->GetSequenceToken()));
 
   bool success = false;
   cache->RequestInitializeOnUIThread(
       base::Bind(&test_util::CopyResultFromInitializeCacheCallback,
                  &success));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_FALSE(success);
 
   cache->DestroyOnUIThread();
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 }
 
-}   // namespace gdata
+}   // namespace drive