Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_file_system_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/mock_directory_change_observer.h"
+#include "chrome/browser/chromeos/gdata/mock_drive_service.h"
 #include "chrome/browser/chromeos/gdata/mock_gdata_cache_observer.h"
-#include "chrome/browser/chromeos/gdata/mock_drive_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.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::Eq;
 using ::testing::NotNull;
@@ skipping 85 matching lines @@
 
   std::string error;
   JSONFileValueSerializer serializer(path);
   base::Value* value = serializer.Deserialize(NULL, &error);
   EXPECT_TRUE(value) <<
       "Parse error " << path.value() << ": " << error;
   return value;
 }
 
 // Counts the number of files (not directories) in |entries|.
-int CountFiles(const GDataEntryProtoVector& entries) {
+int CountFiles(const DriveEntryProtoVector& entries) {
   int num_files = 0;
   for (size_t i = 0; i < entries.size(); ++i) {
     if (!entries[i].file_info().is_directory())
       ++num_files;
   }
   return num_files;
 }
 
 }  // namespace
 
@@ skipping 203 matching lines @@
 
   FilePath GetCachePathForFile(const std::string& resource_id,
                                const std::string& md5) {
     return cache_->GetCacheFilePath(resource_id,
                                     md5,
                                     GDataCache::CACHE_TYPE_TMP,
                                     GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   // Gets entry info by path synchronously.
-  scoped_ptr<GDataEntryProto> GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> GetEntryInfoByPathSync(
       const FilePath& file_path) {
     file_system_->GetEntryInfoByPath(
         file_path,
         base::Bind(&CallbackHelper::GetEntryInfoCallback,
                    callback_helper_.get()));
     test_util::RunBlockingPoolTask();
 
     return callback_helper_->entry_proto_.Pass();
   }
 
   // Gets directory info by path synchronously.
-  scoped_ptr<GDataEntryProtoVector> ReadDirectoryByPathSync(
+  scoped_ptr<DriveEntryProtoVector> ReadDirectoryByPathSync(
       const FilePath& file_path) {
     file_system_->ReadDirectoryByPath(
         file_path,
         base::Bind(&CallbackHelper::ReadDirectoryCallback,
                    callback_helper_.get()));
     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();
   }
 
 
   // Gets the resource ID of |file_path|. Returns an empty string if not found.
   std::string GetResourceIdByPath(const FilePath& file_path) {
-    scoped_ptr<GDataEntryProto> entry_proto =
+    scoped_ptr<DriveEntryProto> entry_proto =
         GetEntryInfoByPathSync(file_path);
     if (entry_proto.get())
       return entry_proto->resource_id();
     else
       return "";
   }
 
   // Helper function to call GetCacheEntry from origin thread.
   bool GetCacheEntryFromOriginThread(const std::string& resource_id,
                                      const std::string& md5,
-                                     GDataCacheEntry* cache_entry) {
+                                     DriveCacheEntry* cache_entry) {
     bool result = false;
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GDataFileSystemTest::GetCacheEntryFromOriginThreadInternal,
                    base::Unretained(this),
                    resource_id,
                    md5,
                    cache_entry,
                    &result));
     test_util::RunBlockingPoolTask();
     return result;
   }
 
   // Used to implement GetCacheEntry.
   void GetCacheEntryFromOriginThreadInternal(
       const std::string& resource_id,
       const std::string& md5,
-      GDataCacheEntry* cache_entry,
+      DriveCacheEntry* cache_entry,
       bool* result) {
     *result = cache_->GetCacheEntry(resource_id, md5, cache_entry);
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     return GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
   }
 
   // Returns true if the cache file exists for the given resource ID and MD5.
   bool CacheFileExists(const std::string& resource_id,
                        const std::string& md5) {
     const FilePath file_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
@@ skipping 127 matching lines @@
   }
 
   void VerifyCacheFileState(GDataFileError error,
                             const std::string& resource_id,
                             const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     const bool cache_entry_found =
         GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
     if (test_util::ToCacheEntry(expected_cache_state_).is_present() ||
         test_util::ToCacheEntry(expected_cache_state_).is_pinned()) {
       ASSERT_TRUE(cache_entry_found);
       EXPECT_TRUE(test_util::CacheStatesEqual(
           test_util::ToCacheEntry(expected_cache_state_),
           cache_entry));
       EXPECT_EQ(expected_sub_dir_type_,
                 GDataCache::GetSubDirectoryType(cache_entry));
@@ skipping 72 matching lines @@
     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() {
-    GDataRootDirectoryProto root;
+    DriveRootDirectoryProto root;
     root.set_version(kProtoVersion);
     root.set_largest_changestamp(654321);
-    GDataDirectoryProto* root_dir = root.mutable_gdata_directory();
-    GDataEntryProto* dir_base = root_dir->mutable_gdata_entry();
+    DriveDirectoryProto* root_dir = root.mutable_gdata_directory();
+    DriveEntryProto* dir_base = root_dir->mutable_gdata_entry();
     PlatformFileInfoProto* platform_info = dir_base->mutable_file_info();
     dir_base->set_title("drive");
     dir_base->set_resource_id(kGDataRootDirectoryResourceId);
     dir_base->set_upload_url("http://resumable-create-media/1");
     platform_info->set_is_directory(true);
 
     // drive/File1
-    GDataEntryProto* file = root_dir->add_child_files();
+    DriveEntryProto* file = root_dir->add_child_files();
     file->set_title("File1");
     file->set_resource_id("resource_id:File1");
     file->set_upload_url("http://resumable-edit-media/1");
     file->mutable_file_specific_info()->set_file_md5("md5");
     platform_info = file->mutable_file_info();
     platform_info->set_is_directory(false);
     platform_info->set_size(1048576);
 
     // drive/Dir1
-    GDataDirectoryProto* dir1 = root_dir->add_child_directories();
+    DriveDirectoryProto* dir1 = root_dir->add_child_directories();
     dir_base = dir1->mutable_gdata_entry();
     dir_base->set_title("Dir1");
     dir_base->set_resource_id("resource_id:Dir1");
     dir_base->set_upload_url("http://resumable-create-media/2");
     platform_info = dir_base->mutable_file_info();
     platform_info->set_is_directory(true);
 
     // drive/Dir1/File2
     file = dir1->add_child_files();
     file->set_title("File2");
     file->set_resource_id("resource_id:File2");
     file->set_upload_url("http://resumable-edit-media/2");
     file->mutable_file_specific_info()->set_file_md5("md5");
     platform_info = file->mutable_file_info();
     platform_info->set_is_directory(false);
     platform_info->set_size(555);
 
     // drive/Dir1/SubDir2
-    GDataDirectoryProto* dir2 = dir1->add_child_directories();
+    DriveDirectoryProto* dir2 = dir1->add_child_directories();
     dir_base = dir2->mutable_gdata_entry();
     dir_base->set_title("SubDir2");
     dir_base->set_resource_id("resource_id:SubDir2");
     dir_base->set_upload_url("http://resumable-create-media/3");
     platform_info = dir_base->mutable_file_info();
     platform_info->set_is_directory(true);
 
     // drive/Dir1/SubDir2/File3
     file = dir2->add_child_files();
     file->set_title("File3");
@@ skipping 12 matching lines @@
     FilePath cache_dir_path = profile_->GetPath().Append(
         FILE_PATH_LITERAL("GCache/v1/meta/"));
     ASSERT_TRUE(file_util::CreateDirectory(cache_dir_path));
     const int file_size = static_cast<int>(serialized_proto.length());
     ASSERT_EQ(file_util::WriteFile(cache_dir_path.Append("file_system.pb"),
         serialized_proto.data(), file_size), file_size);
   }
 
   // Verifies that |file_path| is a valid JSON file for the hosted document
   // associated with |entry| (i.e. |url| and |resource_id| match).
-  void VerifyHostedDocumentJSONFile(const GDataEntryProto& entry_proto,
+  void VerifyHostedDocumentJSONFile(const DriveEntryProto& entry_proto,
                                     const FilePath& file_path) {
     std::string error;
     JSONFileValueSerializer serializer(file_path);
     scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
     ASSERT_TRUE(value.get()) << "Parse error " << file_path.value()
                              << ": " << error;
     DictionaryValue* dict_value = NULL;
     ASSERT_TRUE(value->GetAsDictionary(&dict_value));
 
     std::string edit_url, resource_id;
@@ skipping 48 matching lines @@
       MessageLoop::current()->Quit();
     }
 
     virtual void CloseFileCallback(GDataFileError error) {
       last_error_ = error;
       MessageLoop::current()->Quit();
     }
 
     virtual void GetEntryInfoCallback(
         GDataFileError error,
-        scoped_ptr<GDataEntryProto> entry_proto) {
+        scoped_ptr<DriveEntryProto> entry_proto) {
       last_error_ = error;
       entry_proto_ = entry_proto.Pass();
     }
 
     virtual void ReadDirectoryCallback(
         GDataFileError error,
         bool /* hide_hosted_documents */,
-        scoped_ptr<GDataEntryProtoVector> entries) {
+        scoped_ptr<DriveEntryProtoVector> entries) {
       last_error_ = error;
       directory_entries_ = entries.Pass();
     }
 
     GDataFileError last_error_;
     FilePath download_path_;
     FilePath opened_file_path_;
     std::string mime_type_;
     GDataFileType file_type_;
     int64 quota_bytes_total_;
     int64 quota_bytes_used_;
-    scoped_ptr<GDataEntryProto> entry_proto_;
-    scoped_ptr<GDataEntryProtoVector> directory_entries_;
+    scoped_ptr<DriveEntryProto> entry_proto_;
+    scoped_ptr<DriveEntryProtoVector> directory_entries_;
 
    protected:
     virtual ~CallbackHelper() {}
 
    private:
     friend class base::RefCountedThreadSafe<CallbackHelper>;
   };
 
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
@@ skipping 24 matching lines @@
 };
 
 bool GDataFileSystemTest::cros_initialized_ = false;
 
 void AsyncInitializationCallback(
     int* counter,
     int expected_counter,
     const FilePath& expected_file_path,
     MessageLoop* message_loop,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   ASSERT_EQ(GDATA_FILE_OK, error);
   ASSERT_TRUE(entry_proto.get());
   ASSERT_TRUE(entry_proto->file_info().is_directory());
   EXPECT_EQ(expected_file_path.value(), entry_proto->base_name());
 
   (*counter)++;
   if (*counter >= expected_counter)
     message_loop->Quit();
 }
 
@@ skipping 17 matching lines @@
   file_system_->GetEntryInfoByPath(
       FilePath(FILE_PATH_LITERAL("drive")), callback);
   message_loop_.Run();  // Wait to get our result
   EXPECT_EQ(2, counter);
 }
 
 TEST_F(GDataFileSystemTest, SearchRootDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(FILE_PATH_LITERAL("drive"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(
       FilePath(FILE_PATH_LITERAL(kFilePath)));
   ASSERT_TRUE(entry.get());
   EXPECT_EQ(kGDataRootDirectoryResourceId, entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingFile) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:2_file_resource_id", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Document 1.gdoc"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("document:5_document_resource_id", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchNonExistingFile) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/nonexisting.file"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_FALSE(entry.get());
 }
 
 TEST_F(GDataFileSystemTest, SearchEncodedFileNames) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("drive/Slash / in file 1.txt"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_FALSE(entry.get());
 
   const FilePath kFilePath2 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const FilePath kFilePath3 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetEntryInfoByPathSync(kFilePath3);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchEncodedFileNamesLoadingRoot) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("drive/Slash / in file 1.txt"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_FALSE(entry.get());
 
   const FilePath kFilePath2 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const FilePath kFilePath3 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetEntryInfoByPathSync(kFilePath3);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchDuplicateNames) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:3_file_resource_id", entry->resource_id());
 
   const FilePath kFilePath2 = FilePath(
       FILE_PATH_LITERAL("drive/Duplicate Name (2).txt"));
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:4_file_resource_id", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Directory 1"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("folder:1_folder_resource_id", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, SearchInSubdir) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("file:subdirectory_file_1_id", entry->resource_id());
 }
 
 // Check the reconstruction of the directory structure from only the root feed.
 TEST_F(GDataFileSystemTest, SearchInSubSubdir) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Directory 1/Sub Directory Folder/"
                         "Sub Sub Directory Folder"));
-  scoped_ptr<GDataEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("folder:sub_sub_directory_folder_id", entry->resource_id());
 }
 
 TEST_F(GDataFileSystemTest, FilePathTests) {
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/File 1.txt"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))));
   EXPECT_TRUE(EntryExists(
@@ skipping 300 matching lines @@
 
   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/File 1.txt"));
-  scoped_ptr<GDataEntryProto> file = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> file = GetEntryInfoByPathSync(
       remote_src_file_path);
   FilePath cache_file = GetCachePathForFile(
       file->resource_id(),
       file->file_specific_info().file_md5());
   const int64 file_size = file->file_info().size();
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
@@ skipping 39 matching lines @@
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath local_dest_file_path = temp_dir.path().Append("local_copy.txt");
   FilePath remote_src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path, local_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
 
-  scoped_ptr<GDataEntryProto> entry_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> entry_proto = GetEntryInfoByPathSync(
       remote_src_file_path);
   ASSERT_TRUE(entry_proto.get());
   VerifyHostedDocumentJSONFile(*entry_proto, local_dest_file_path);
 }
 
 TEST_F(GDataFileSystemTest, CopyNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
@@ skipping 13 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, CopyFileToNonExistingDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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,
@@ skipping 12 matching lines @@
 // not a directory.
 TEST_F(GDataFileSystemTest, CopyFileToInvalidPath) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL(
       "drive/Duplicate Name.txt/Document 1.gdoc"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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());
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
-  scoped_ptr<GDataEntryProto> dest_entry_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> dest_entry_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_entry_proto.get());
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Copy(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_A_DIRECTORY,
             callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
 
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, RenameFile) {
   const FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
   const FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   const FilePath dest_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
 
   FileOperationCallback callback =
@@ skipping 13 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, MoveFileFromRootToSubDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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());
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
-  scoped_ptr<GDataEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
   ASSERT_TRUE(dest_parent_proto->file_info().is_directory());
   EXPECT_FALSE(dest_parent_proto->content_url().empty());
 
   EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
   EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(
@@ skipping 21 matching lines @@
 
 TEST_F(GDataFileSystemTest, MoveFileFromSubDirectoryToRoot) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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());
 
   ASSERT_TRUE(EntryExists(src_parent_path));
-  scoped_ptr<GDataEntryProto> src_parent_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> src_parent_proto = GetEntryInfoByPathSync(
       src_parent_path);
   ASSERT_TRUE(src_parent_proto.get());
   ASSERT_TRUE(src_parent_proto->file_info().is_directory());
   EXPECT_FALSE(src_parent_proto->content_url().empty());
 
   EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
   EXPECT_CALL(*mock_drive_service_,
               RemoveResourceFromDirectory(
@@ skipping 29 matching lines @@
   FilePath interim_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   AddDirectoryFromFile(dest_parent_path, "directory_entry_atom.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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());
 
   ASSERT_TRUE(EntryExists(src_parent_path));
-  scoped_ptr<GDataEntryProto> src_parent_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> src_parent_proto = GetEntryInfoByPathSync(
       src_parent_path);
   ASSERT_TRUE(src_parent_proto.get());
   ASSERT_TRUE(src_parent_proto->file_info().is_directory());
   EXPECT_FALSE(src_parent_proto->content_url().empty());
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
-  scoped_ptr<GDataEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
   ASSERT_TRUE(dest_parent_proto->file_info().is_directory());
   EXPECT_FALSE(dest_parent_proto->content_url().empty());
 
   EXPECT_FALSE(EntryExists(interim_file_path));
 
   EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
@@ skipping 54 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, MoveFileToNonExistingDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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,
@@ skipping 12 matching lines @@
 // not a directory.
 TEST_F(GDataFileSystemTest, MoveFileToInvalidPath) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL(
       "drive/Duplicate Name.txt/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
-  scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
+  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());
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
-  scoped_ptr<GDataEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_A_DIRECTORY,
             callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, RemoveEntries) {
   LoadRootFeedDocument("root_feed.json");
 
   FilePath nonexisting_file(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dir_in_root(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath file_in_subdir(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
 
   ASSERT_TRUE(EntryExists(file_in_root));
-  scoped_ptr<GDataEntryProto> file_in_root_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> file_in_root_proto = GetEntryInfoByPathSync(
       file_in_root);
   ASSERT_TRUE(file_in_root_proto.get());
 
   ASSERT_TRUE(EntryExists(dir_in_root));
-  scoped_ptr<GDataEntryProto> dir_in_root_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> dir_in_root_proto = GetEntryInfoByPathSync(
       dir_in_root);
   ASSERT_TRUE(dir_in_root_proto.get());
   ASSERT_TRUE(dir_in_root_proto->file_info().is_directory());
 
   ASSERT_TRUE(EntryExists(file_in_subdir));
-  scoped_ptr<GDataEntryProto> file_in_subdir_proto = GetEntryInfoByPathSync(
+  scoped_ptr<DriveEntryProto> file_in_subdir_proto = GetEntryInfoByPathSync(
       file_in_subdir);
   ASSERT_TRUE(file_in_subdir_proto.get());
 
   // Once for file in root and once for file...
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(2);
 
   // Remove first file in root.
   EXPECT_TRUE(RemoveEntry(file_in_root));
   EXPECT_FALSE(EntryExists(file_in_root));
@@ skipping 120 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  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.
@@ skipping 20 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  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.
@@ skipping 17 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  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 no space first (checked before downloading a file),
   // but then start reporting we have space. This is to emulate that
   // the disk space was freed up by removing temporary files.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .WillOnce(Return(file_size + kMinFreeSpace))
@@ skipping 41 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  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 first (checked before downloading a file),
   // but then start reporting we have not enough space. This is to emulate that
   // 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())
@@ skipping 26 matching lines @@
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
                    GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
@@ skipping 20 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_HostedDocument) {
   LoadRootFeedDocument("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<GDataEntryProto> src_entry_proto =
+  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();
 
   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(GDataFileSystemTest, GetFileByResourceId) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  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(LoadJSONFile("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
@@ skipping 19 matching lines @@
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
+  scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
                    GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
@@ skipping 133 matching lines @@
               OnDirectoryChanged(Eq(FilePath(kGDataRootDirectory)))).Times(1);
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Check the number of files in the root directory. We'll compare the
   // number after updating a file.
-  scoped_ptr<GDataEntryProtoVector> root_directory_entries(
+  scoped_ptr<DriveEntryProtoVector> root_directory_entries(
       ReadDirectoryByPathSync(FilePath::FromUTF8Unsafe("drive")));
   ASSERT_TRUE(root_directory_entries.get());
   const int num_files_in_root = CountFiles(*root_directory_entries);
 
   file_system_->UpdateFileByResourceId(kResourceId, callback);
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
   // 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
@@ skipping 125 matching lines @@
   LoadRootFeedDocument("root_feed.json");
 
   OpenFileCallback callback =
       base::Bind(&CallbackHelper::OpenFileCallback,
                  callback_helper_.get());
   FileOperationCallback close_file_callback =
       base::Bind(&CallbackHelper::CloseFileCallback,
                  callback_helper_.get());
 
   const FilePath kFileInRoot(FILE_PATH_LITERAL("drive/File 1.txt"));
-  scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(kFileInRoot));
+  scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(kFileInRoot));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
   const int64 file_size = entry_proto->file_info().size();
   const std::string& file_resource_id =
       entry_proto->resource_id();
   const std::string& file_md5 = entry_proto->file_specific_info().file_md5();
 
   // A dirty file is created on close.
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(file_resource_id))
@@ skipping 59 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata