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

chrome/browser/chromeos/drive/drive_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 "chrome/browser/chromeos/drive/drive_file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 28 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::Eq;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 using ::testing::_;
 
-namespace gdata {
+namespace drive {
 namespace {
 
 const char kSymLinkToDevNull[] = "/dev/null";
 
 const int64 kLotsOfSpace = kMinFreeSpace * 10;
 
 struct SearchResultPair {
   const char* path;
   const bool is_directory;
 };
@@ skipping 24 matching lines @@
 // DriveServiceInterface::GetDocumentEntry().
 ACTION_P2(MockGetDocumentEntry, status, value) {
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg1, status, base::Passed(value)));
 }
 
 // Action used to set mock expectations for
 // DriveUploaderInterface::UploadExistingFile().
 ACTION_P4(MockUploadExistingFile,
           error, drive_path, local_file_path, document_entry) {
-  scoped_ptr<DocumentEntry> scoped_document_entry(document_entry);
+  scoped_ptr<gdata::DocumentEntry> scoped_document_entry(document_entry);
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg5,
                  error,
                  drive_path,
                  local_file_path,
                  base::Passed(&scoped_document_entry)));
 
   const int kUploadId = 123;
   return kUploadId;
 }
 
 // Action used to set mock expectations for
 // DriveUploaderInterface::UploadNewFile().
 ACTION(MockUploadNewFile) {
   scoped_ptr<base::Value> value =
-      test_util::LoadJSONFile("gdata/uploaded_file.json");
-  scoped_ptr<DocumentEntry> document_entry(
-      DocumentEntry::ExtractAndParse(*value));
+      gdata::test_util::LoadJSONFile("gdata/uploaded_file.json");
+  scoped_ptr<gdata::DocumentEntry> document_entry(
+      gdata::DocumentEntry::ExtractAndParse(*value));
 
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg7,
                  DRIVE_FILE_OK,
                  arg1,
                  arg2,
                  base::Passed(&document_entry)));
 
   const int kUploadId = 123;
   return kUploadId;
@@ skipping 74 matching lines @@
                                        blocking_task_runner_);
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
     cache_->RequestInitializeOnUIThreadForTesting();
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(file_system_);
     EXPECT_CALL(*mock_drive_service_, CancelAll()).Times(1);
     delete file_system_;
     file_system_ = NULL;
     delete mock_drive_service_;
     mock_drive_service_ = NULL;
     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);
   }
 
   // Loads test json file as root ("/drive") element.
   void LoadRootFeedDocument(const std::string& filename) {
     LoadChangeFeed(filename, 0);
   }
 
   void LoadChangeFeed(const std::string& filename,
                       int largest_changestamp) {
     test_util::LoadChangeFeed(filename,
                               file_system_,
                               largest_changestamp,
                               root_feed_changestamp_);
     root_feed_changestamp_++;
   }
 
   void AddDirectoryFromFile(const FilePath& directory_path,
                             const std::string& filename) {
-    scoped_ptr<Value> atom = test_util::LoadJSONFile(filename);
+    scoped_ptr<Value> atom = gdata::test_util::LoadJSONFile(filename);
     ASSERT_TRUE(atom.get());
     ASSERT_TRUE(atom->GetType() == Value::TYPE_DICTIONARY);
 
     DictionaryValue* dict_value = NULL;
     Value* entry_value = NULL;
     ASSERT_TRUE(atom->GetAsDictionary(&dict_value));
     ASSERT_TRUE(dict_value->Get("entry", &entry_value));
 
     DictionaryValue* entry_dict = NULL;
     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]);
 
     DriveFileError error;
     DriveFileSystem::CreateDirectoryParams params(directory_path,
                                                   directory_path,
                                                   false,  // is_exclusive
                                                   false,  // is_recursive
         base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
-    file_system_->AddNewDirectory(params, HTTP_SUCCESS, atom.Pass());
-    test_util::RunBlockingPoolTask();
+    file_system_->AddNewDirectory(params, gdata::HTTP_SUCCESS, atom.Pass());
+    gdata::test_util::RunBlockingPoolTask();
     EXPECT_EQ(DRIVE_FILE_OK, error);
   }
 
   bool RemoveEntry(const FilePath& file_path) {
     DriveFileError error;
     EXPECT_CALL(*mock_drive_service_, DeleteDocument(_, _)).Times(AnyNumber());
     file_system_->remove_operation_->Remove(
         file_path, false,
         base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
 
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
     return error == 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);
   }
 
   // Gets entry info by path synchronously.
   scoped_ptr<DriveEntryProto> GetEntryInfoByPathSync(
       const FilePath& file_path) {
     file_system_->GetEntryInfoByPath(
         file_path,
         base::Bind(&CallbackHelper::GetEntryInfoCallback,
                    callback_helper_.get()));
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
 
     return callback_helper_->entry_proto_.Pass();
   }
 
   // Gets directory info by path synchronously.
   scoped_ptr<DriveEntryProtoVector> ReadDirectoryByPathSync(
       const FilePath& file_path) {
     file_system_->ReadDirectoryByPath(
         file_path,
         base::Bind(&CallbackHelper::ReadDirectoryCallback,
                    callback_helper_.get()));
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
 
     return callback_helper_->directory_entries_.Pass();
   }
 
   // Returns true if an entry exists at |file_path|.
   bool EntryExists(const FilePath& file_path) {
     return GetEntryInfoByPathSync(file_path).get();
   }
 
 
@@ skipping 13 matching lines @@
                                      DriveCacheEntry* cache_entry) {
     bool result = false;
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DriveFileSystemTest::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 27 matching lines @@
     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(&DriveFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   void TestPin(
       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_->PinOnUIThread(
         resource_id, md5,
         base::Bind(&DriveFileSystemTest::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(&DriveFileSystemTest::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(&DriveFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
-    test_util::RunBlockingPoolTask();
+    gdata::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(DriveFileError error,
                                      const std::string& resource_id,
                                      const std::string& md5,
                                      const FilePath& cache_file_path) {
     expected_error_ = DRIVE_FILE_OK;
@@ skipping 104 matching lines @@
   void SetExpectationsForGetDocumentEntry(scoped_ptr<base::Value>* document,
                                           const std::string& resource_id) {
     EXPECT_CALL(*mock_drive_service_, GetDocumentEntry(resource_id, _))
         .WillOnce(MockGetDocumentEntry(gdata::HTTP_SUCCESS, document));
   }
 
   // Loads serialized proto file from GCache, and makes sure the root
   // filesystem has a root at 'drive'
   void TestLoadMetadataFromCache() {
     file_system_->LoadRootFeedFromCacheForTesting();
-    test_util::RunBlockingPoolTask();
+    gdata::test_util::RunBlockingPoolTask();
   }
 
   // Creates a proto file representing a filesystem with directories:
   // drive, drive/Dir1, drive/Dir1/SubDir2
   // and files
   // drive/File1, drive/Dir1/File2, drive/Dir1/SubDir2/File3.
   // Sets the changestamp to 654321, equal to that of "account_metadata.json"
   // test data, indicating the cache is holding the latest file system info.
   void SaveTestFileSystem() {
     DriveRootDirectoryProto root;
@@ skipping 565 matching lines @@
   EXPECT_TRUE(EntryExists(
       FilePath(FILE_PATH_LITERAL("drive/Dir1/SubDir2/File3"))));
 }
 
 TEST_F(DriveFileSystemTest, CachedFeadLoadingThenServerFeedLoading) {
   SaveTestFileSystem();
 
   // SaveTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (i.e., call to GetDocuments) should happen.
   mock_drive_service_->set_account_metadata(
-      test_util::LoadJSONFile("gdata/account_metadata.json").release());
+      gdata::test_util::LoadJSONFile("gdata/account_metadata.json").release());
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
   EXPECT_CALL(*mock_drive_service_, GetDocuments(_, _, _, _, _)).Times(0);
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/File1"))));
 
   // Since the file system has verified that it holds the latest snapshot,
   // it should change its state to FROM_SERVER, which admits periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check updates.
   mock_drive_service_->set_account_metadata(
-      test_util::LoadJSONFile("gdata/account_metadata.json").release());
+      gdata::test_util::LoadJSONFile("gdata/account_metadata.json").release());
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
 
   file_system_->CheckForUpdates();
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("gdata/root_feed.json");
 
   // We'll add a file to the Drive root directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Prepare a local file.
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const FilePath local_src_file_path = temp_dir.path().Append("local.txt");
   const std::string kContent = "hello";
   file_util::WriteFile(local_src_file_path, kContent.data(), kContent.size());
 
   // 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));
 
   scoped_ptr<base::Value> value =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
-  scoped_ptr<DocumentEntry> document_entry(
-      DocumentEntry::ExtractAndParse(*value));
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
+  scoped_ptr<gdata::DocumentEntry> document_entry(
+      gdata::DocumentEntry::ExtractAndParse(*value));
 
   EXPECT_CALL(*mock_uploader_, UploadNewFile(_, _, _, _, _, _, _, _, _))
       .WillOnce(MockUploadNewFile());
 
   // Transfer the local file to Drive.
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
@@ skipping 15 matching lines @@
       FILE_PATH_LITERAL("drive/Directory 1/Document 1.gdoc"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   // We'll add a file to "Directory 1" directory on Drive.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   // We'll copy a hosted document using CopyDocument.
   // ".gdoc" suffix should be stripped when copying.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/uploaded_document.json");
+      gdata::test_util::LoadJSONFile("gdata/uploaded_document.json");
   EXPECT_CALL(*mock_drive_service_,
               CopyDocument(kResourceId,
                            FILE_PATH_LITERAL("Document 1"),
                            _))
       .WillOnce(MockCopyDocument(gdata::HTTP_SUCCESS, &document));
   // We'll then add the hosted document to the destination directory.
   EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(_, _, _)).Times(1);
 
   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();
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
@@ skipping 16 matching lines @@
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string remote_src_file_data = "Test file data";
   mock_drive_service_->set_file_data(new std::string(remote_src_file_data));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   EXPECT_CALL(*mock_drive_service_,
               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();
+  gdata::test_util::RunBlockingPoolTask();
 
   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(DriveFileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
   LoadRootFeedDocument("gdata/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();
+  gdata::test_util::RunBlockingPoolTask();
 
   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(DriveFileSystemTest, CopyNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("gdata/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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, 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("gdata/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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, CopyFileToInvalidPath) {
@@ skipping 15 matching lines @@
   ASSERT_TRUE(EntryExists(dest_parent_path));
   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();
+  gdata::test_util::RunBlockingPoolTask();
   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));
 }
 
@@ skipping 18 matching lines @@
                              FILE_PATH_LITERAL("Test.log"), _));
 
   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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, MoveFileFromRootToSubDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
@@ skipping 28 matching lines @@
       base::Bind(&CallbackHelper::FileOperationCallback,
                  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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, MoveFileFromSubDirectoryToRoot) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
@@ skipping 30 matching lines @@
       base::Bind(&CallbackHelper::FileOperationCallback,
                  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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, MoveFileBetweenSubDirectories) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
@@ skipping 54 matching lines @@
   // Expect notification for both source and destination directories plus
   // 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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, MoveNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("gdata/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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, 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("gdata/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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, MoveFileToInvalidPath) {
@@ skipping 15 matching lines @@
   ASSERT_TRUE(EntryExists(dest_parent_path));
   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();
+  gdata::test_util::RunBlockingPoolTask();
   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(DriveFileSystemTest, RemoveEntries) {
   LoadRootFeedDocument("gdata/root_feed.json");
@@ skipping 39 matching lines @@
   // Try removing file in already removed subdirectory.
   EXPECT_FALSE(RemoveEntry(file_in_subdir));
 
   // Try removing non-existing file.
   EXPECT_FALSE(RemoveEntry(nonexisting_file));
 
   // Try removing root file element.
   EXPECT_FALSE(RemoveEntry(FilePath(FILE_PATH_LITERAL("drive"))));
 
   // Need this to ensure OnDirectoryChanged() is run.
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 }
 
 TEST_F(DriveFileSystemTest, CreateDirectory) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   // Create directory in root.
   FilePath dir_path(FILE_PATH_LITERAL("drive/New Folder 1"));
@@ skipping 15 matching lines @@
   LoadRootFeedDocument("gdata/root_feed.json");
 
   DriveFileSystem::FindFirstMissingParentDirectoryResult result;
 
   // Create directory in root.
   FilePath dir_path(FILE_PATH_LITERAL("drive/New Folder 1"));
   file_system_->FindFirstMissingParentDirectory(
       dir_path,
       base::Bind(&CopyResultFromFindFirstMissingParentDirectory,
                  &result));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DriveFileSystem::FIND_FIRST_FOUND_MISSING, result.error);
   EXPECT_EQ(FilePath(FILE_PATH_LITERAL("drive/New Folder 1")),
             result.first_missing_parent_path);
   EXPECT_TRUE(result.last_dir_content_url.is_empty());  // root directory.
 
   // Missing folders in subdir of an existing folder.
   FilePath dir_path2(FILE_PATH_LITERAL("drive/Directory 1/New Folder 2"));
   file_system_->FindFirstMissingParentDirectory(
       dir_path2,
       base::Bind(&CopyResultFromFindFirstMissingParentDirectory,
                  &result));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DriveFileSystem::FIND_FIRST_FOUND_MISSING, result.error);
   EXPECT_EQ(FilePath(FILE_PATH_LITERAL("drive/Directory 1/New Folder 2")),
             result.first_missing_parent_path);
   EXPECT_FALSE(result.last_dir_content_url.is_empty());  // non-root dir.
 
   // Missing two folders on the path.
   FilePath dir_path3 = dir_path2.Append(FILE_PATH_LITERAL("Another Folder"));
   file_system_->FindFirstMissingParentDirectory(
       dir_path3,
       base::Bind(&CopyResultFromFindFirstMissingParentDirectory,
                  &result));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DriveFileSystem::FIND_FIRST_FOUND_MISSING, result.error);
   EXPECT_EQ(FilePath(FILE_PATH_LITERAL("drive/Directory 1/New Folder 2")),
             result.first_missing_parent_path);
   EXPECT_FALSE(result.last_dir_content_url.is_empty());  // non-root dir.
 
   // Folders on top of an existing file.
   file_system_->FindFirstMissingParentDirectory(
       FilePath(FILE_PATH_LITERAL("drive/File 1.txt/BadDir")),
       base::Bind(&CopyResultFromFindFirstMissingParentDirectory,
                  &result));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DriveFileSystem::FIND_FIRST_FOUND_INVALID, result.error);
 
   // Existing folder.
   file_system_->FindFirstMissingParentDirectory(
       FilePath(FILE_PATH_LITERAL("drive/Directory 1")),
       base::Bind(&CopyResultFromFindFirstMissingParentDirectory,
                  &result));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DriveFileSystem::FIND_FIRST_DIRECTORY_ALREADY_PRESENT,
             result.error);
 }
 
 // Create a directory through the document service
 TEST_F(DriveFileSystemTest, CreateDirectoryWithService) {
   LoadRootFeedDocument("gdata/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<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();
+  gdata::test_util::RunBlockingPoolTask();
   // TODO(gspencer): Uncomment this when we get a blob that
   // works that can be returned from the mock.
   // EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   LoadRootFeedDocument("gdata/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());
   const int64 file_size = entry_proto->file_info().size();
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   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();
+                              gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   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(DriveFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   LoadRootFeedDocument("gdata/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());
 
   // Pretend we have no space at all.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(0));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is not obtained with the mock DriveService, because of no space.
   EXPECT_CALL(*mock_drive_service_,
               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();
+                              gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE,
             callback_helper_->last_error_);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
@@ skipping 11 matching lines @@
   // the disk space was freed up by removing temporary files.
   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>",
-                   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);
   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 =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/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();
+                              gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   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 18 matching lines @@
   // the disk space becomes full after the file is downloaded for some reason
   // (ex. the actual file was larger than the expected size).
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(kMinFreeSpace - 1))
       .WillOnce(Return(kMinFreeSpace - 1));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   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();
+                              gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE,
             callback_helper_->last_error_);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("gdata/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(),
-                   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);
 
   // 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,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(0);
 
   file_system_->GetFileByPath(file_in_root, callback,
-                              GetContentCallback());
-  test_util::RunBlockingPoolTask();
+                              gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_HostedDocument) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   scoped_ptr<DriveEntryProto> src_entry_proto =
       GetEntryInfoByPathSync(file_in_root);
   ASSERT_TRUE(src_entry_proto.get());
 
   file_system_->GetFileByPath(file_in_root, callback,
-                              GetContentCallback());
-  test_util::RunBlockingPoolTask();
+                              gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(HOSTED_DOCUMENT, callback_helper_->file_type_);
   EXPECT_FALSE(callback_helper_->download_path_.empty());
 
   ASSERT_TRUE(src_entry_proto.get());
   VerifyHostedDocumentJSONFile(*src_entry_proto,
                                callback_helper_->download_path_);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByResourceId) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("gdata/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());
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService, because it's not stored in
   // the cache.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByResourceId(entry_proto->resource_id(),
                                     callback,
-                                    GetContentCallback());
-  test_util::RunBlockingPoolTask();
+                                    gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
 TEST_F(DriveFileSystemTest, GetFileByResourceId_FromCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("gdata/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(),
-                   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);
 
   // 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,
-                                    GetContentCallback());
-  test_util::RunBlockingPoolTask();
+                                    gdata::GetContentCallback());
+  gdata::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
 TEST_F(DriveFileSystemTest, UpdateFileByResourceId_PersistentFile) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
@@ skipping 14 matching lines @@
 
   // 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,
                    // Anything works.
-                   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);
   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,
@@ skipping 29 matching lines @@
                   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));
   ASSERT_TRUE(file_util::PathExists(outgoing_symlink_path));
 
-  // Create a DocumentEntry, which is needed to mock
+  // Create a gdata::DocumentEntry, which is needed to mock
   // DriveUploaderInterface::UploadExistingFile().
   // TODO(satorux): This should be cleaned up. crbug.com/134240.
-  DocumentEntry* document_entry = NULL;
+  gdata::DocumentEntry* document_entry = NULL;
   scoped_ptr<base::Value> value =
-      test_util::LoadJSONFile("gdata/root_feed.json");
+      gdata::test_util::LoadJSONFile("gdata/root_feed.json");
   ASSERT_TRUE(value.get());
   base::DictionaryValue* as_dict = NULL;
   base::ListValue* entry_list = NULL;
   if (value->GetAsDictionary(&as_dict) &&
       as_dict->GetList("feed.entry", &entry_list)) {
     for (size_t i = 0; i < entry_list->GetSize(); ++i) {
       base::DictionaryValue* entry = NULL;
       std::string resource_id;
       if (entry_list->GetDictionary(i, &entry) &&
           entry->GetString("gd$resourceId.$t", &resource_id) &&
           resource_id == kResourceId) {
         // This will be deleted by UploadExistingFile().
-        document_entry = DocumentEntry::CreateFrom(*entry);
+        document_entry = gdata::DocumentEntry::CreateFrom(*entry);
       }
     }
   }
   ASSERT_TRUE(document_entry);
 
   // 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,
@@ skipping 18 matching lines @@
                  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();
+  gdata::test_util::RunBlockingPoolTask();
 
   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(DriveFileSystemTest, UpdateFileByResourceId_NonexistentFile) {
   LoadRootFeedDocument("gdata/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();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 TEST_F(DriveFileSystemTest, ContentSearch) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
   mock_drive_service_->set_search_result("gdata/search_result_feed.json");
 
   EXPECT_CALL(*mock_drive_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
       .Times(1);
@@ skipping 61 matching lines @@
 }
 
 TEST_F(DriveFileSystemTest, GetAvailableSpace) {
   GetAvailableSpaceCallback callback =
       base::Bind(&CallbackHelper::GetAvailableSpaceCallback,
                  callback_helper_.get());
 
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_));
 
   file_system_->GetAvailableSpace(callback);
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
   EXPECT_EQ(GG_LONGLONG(6789012345), callback_helper_->quota_bytes_used_);
   EXPECT_EQ(GG_LONGLONG(9876543210), callback_helper_->quota_bytes_total_);
 }
 
 TEST_F(DriveFileSystemTest, RequestDirectoryRefresh) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
   // We'll fetch documents in the root directory with its resource ID.
   EXPECT_CALL(*mock_drive_service_,
               GetDocuments(Eq(GURL()), _, _, kDriveRootDirectoryResourceId, _))
       .Times(1);
   // We'll notify the directory change to the observer.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kDriveRootDirectory)))).Times(1);
 
   file_system_->RequestDirectoryRefresh(FilePath(kDriveRootDirectory));
-  test_util::RunBlockingPoolTask();
+  gdata::test_util::RunBlockingPoolTask();
 }
 
 TEST_F(DriveFileSystemTest, OpenAndCloseFile) {
   LoadRootFeedDocument("gdata/root_feed.json");
 
   OpenFileCallback callback =
       base::Bind(&CallbackHelper::OpenFileCallback,
                  callback_helper_.get());
   FileOperationCallback close_file_callback =
       base::Bind(&CallbackHelper::CloseFileCallback,
@@ skipping 16 matching lines @@
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string kExpectedFileData = "test file data";
   mock_drive_service_->set_file_data(new std::string(kExpectedFileData));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document =
-      test_util::LoadJSONFile("gdata/document_to_download.json");
+      gdata::test_util::LoadJSONFile("gdata/document_to_download.json");
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(kFileInRoot,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
@@ skipping 36 matching lines @@
                                  file_md5);
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
-}   // namespace gdata
+}   // namespace drive