Implement copy and move operations within the same remote file system.

chrome/browser/chromeos/gdata/gdata_file_system_unittest.cc

Index: chrome/browser/chromeos/gdata/gdata_file_system_unittest.cc
===================================================================
--- chrome/browser/chromeos/gdata/gdata_file_system_unittest.cc	(revision 126271)
+++ chrome/browser/chromeos/gdata/gdata_file_system_unittest.cc	(working copy)
@@ -319,6 +319,8 @@
       download_path_ = file_path;
     }
     virtual void FileOperationCallback(base::PlatformFileError error) {
+      DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
       last_error_ = error;
     }
 
@@ -355,7 +357,7 @@
   }
 
   // gdata::FindFileDelegate overrides.
-  MOCK_METHOD1(OnFileFound, void(GDataFile*));
+  MOCK_METHOD1(OnFileFound, void(GDataFile* file));
   MOCK_METHOD2(OnDirectoryFound, void(const FilePath&, GDataDirectory* dir));
   MOCK_METHOD2(OnEnterDirectory, FindFileTraversalCommand(
       const FilePath&, GDataDirectory* dir));
@@ -539,6 +541,440 @@
       FilePath(FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt")));
 }
 
+TEST_F(GDataFileSystemTest, GetCopyMoveFileParams) {
+  LoadRootFeedDocument("root_feed.json");
+  LoadSubdirFeedDocument(FilePath(FILE_PATH_LITERAL("gdata/Directory 1")),
+                         "subdir_feed.json");
+
+  // Create directory in root.
+  FilePath dir_path(FILE_PATH_LITERAL("gdata/New Folder 1"));
+  AddDirectoryFromFile(dir_path, "directory_entry_atom.json");
+
+  // Create directory in a sub dirrectory.
+  FilePath subdir_path(FILE_PATH_LITERAL("gdata/New Folder 1/New Folder 2"));
+  AddDirectoryFromFile(subdir_path, "directory_entry_atom.json");
+
+  // Non-existing file
+  GDataFileSystem::CopyMoveFileParams params;
+  EXPECT_FALSE(file_system_->GetCopyMoveFileParams(FilePath("gdata/Dummy"),
+                                                   &params));
+  EXPECT_EQ("", params.self_url.spec());
+  EXPECT_EQ("", params.content_url.spec());
+  EXPECT_EQ("", params.resource_id);
+  EXPECT_EQ("", params.document_extension);
+  EXPECT_FALSE(params.is_directory);
+  EXPECT_FALSE(params.is_root_directory);
+  EXPECT_FALSE(params.is_hosted_document);
+
+  // Root directory
+  GDataFileSystem::CopyMoveFileParams root_params;
+  EXPECT_TRUE(file_system_->GetCopyMoveFileParams(FilePath("gdata"),
+                                                  &root_params));
+  EXPECT_EQ("", root_params.self_url.spec());
+  EXPECT_EQ("", root_params.content_url.spec());
+  EXPECT_EQ("", root_params.resource_id);
+  EXPECT_EQ("", root_params.document_extension);
+  EXPECT_TRUE(root_params.is_directory);
+  EXPECT_TRUE(root_params.is_root_directory);
+  EXPECT_FALSE(root_params.is_hosted_document);
+
+  // Subdirectory
+  GDataFileSystem::CopyMoveFileParams subdir_params;
+  EXPECT_TRUE(file_system_->GetCopyMoveFileParams(FilePath("gdata/Directory 1"),
+                                                  &subdir_params));
+  EXPECT_EQ("https://1_self_link/", subdir_params.self_url.spec());
+  EXPECT_EQ("https://1_folder_content_url/", subdir_params.content_url.spec());
+  EXPECT_EQ("folder:1_folder_resource_id", subdir_params.resource_id);
+  EXPECT_EQ("", subdir_params.document_extension);
+  EXPECT_TRUE(subdir_params.is_directory);
+  EXPECT_FALSE(subdir_params.is_root_directory);
+  EXPECT_FALSE(subdir_params.is_hosted_document);
+
+  // Regular file
+  GDataFileSystem::CopyMoveFileParams file_params;
+  EXPECT_TRUE(file_system_->GetCopyMoveFileParams(FilePath("gdata/File 1.txt"),
+                                                  &file_params));
+  EXPECT_EQ("https://file_link_self/", file_params.self_url.spec());
+  EXPECT_EQ("https://file_content_url/", file_params.content_url.spec());
+  EXPECT_EQ("file:2_file_resource_id", file_params.resource_id);
+  EXPECT_EQ("", file_params.document_extension);
+  EXPECT_FALSE(file_params.is_directory);
+  EXPECT_FALSE(file_params.is_root_directory);
+  EXPECT_FALSE(file_params.is_hosted_document);
+
+  // Hosted document
+  GDataFileSystem::CopyMoveFileParams doc_params;
+  EXPECT_TRUE(file_system_->GetCopyMoveFileParams(
+      FilePath("gdata/Document 1.gdoc"), &doc_params));
+  EXPECT_EQ("https://3_document_self_link/", doc_params.self_url.spec());
+  EXPECT_EQ("https://3_document_content/", doc_params.content_url.spec());
+  EXPECT_EQ("document:5_document_resource_id", doc_params.resource_id);
+  EXPECT_EQ(".gdoc", doc_params.document_extension);
+  EXPECT_FALSE(doc_params.is_directory);
+  EXPECT_FALSE(doc_params.is_root_directory);
+  EXPECT_TRUE(doc_params.is_hosted_document);
+}
+
+TEST_F(GDataFileSystemTest, CopyNotExistingFile) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/Dummy file.txt"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) == NULL);
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Copy(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+
+  EXPECT_TRUE(FindFile(src_file_path) == NULL);
+  EXPECT_TRUE(FindFile(dest_file_path) == NULL);
+}
+
+TEST_F(GDataFileSystemTest, CopyFileToNonExistingDirectory) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/File 1.txt"));
+  FilePath dest_parent_path(FILE_PATH_LITERAL("gdata/Dummy"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Dummy/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  EXPECT_TRUE(FindFile(dest_parent_path) == NULL);
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+
+  EXPECT_EQ(src_file, FindFile(src_file_path));
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+
+  EXPECT_TRUE(FindFile(dest_parent_path) == NULL);
+  EXPECT_TRUE(FindFile(dest_file_path) == NULL);
+}
+
+// Test the case where the parent of |dest_file_path| is a existing file,
+// not a directory.
+TEST_F(GDataFileSystemTest, CopyFileToInvalidPath) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/Document 1.gdoc"));
+  FilePath dest_parent_path(FILE_PATH_LITERAL("gdata/Duplicate Name.txt"));
+  FilePath dest_file_path(FILE_PATH_LITERAL(
+      "gdata/Duplicate Name.txt/Document 1.gdoc"));
+
+  LoadRootFeedDocument("root_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  GDataFileBase* dest_parent = NULL;
+  EXPECT_TRUE((dest_parent = FindFile(dest_parent_path)) != NULL);
+  EXPECT_TRUE(dest_parent->AsGDataFile() != NULL);
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Copy(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
+            callback_helper_->last_error_);
+
+  EXPECT_EQ(src_file, FindFile(src_file_path));
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_EQ(dest_parent, FindFile(dest_parent_path));
+
+  EXPECT_TRUE(FindFile(dest_file_path) == NULL);
+}
+
+TEST_F(GDataFileSystemTest, RenameFile) {
+  FilePath src_file_path(
+      FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt"));
+  FilePath src_parent_path(FILE_PATH_LITERAL("gdata/Directory 1"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Directory 1/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+  LoadSubdirFeedDocument(src_parent_path, "subdir_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_resource));
+
+  EXPECT_CALL(*mock_doc_service_,
+              RenameResource(src_file->self_url(),
+                             FILE_PATH_LITERAL("Test.log"), _));
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
+
+  EXPECT_TRUE(FindFile(src_file_path) == NULL);
+
+  GDataFileBase* dest_file = NULL;
+  EXPECT_TRUE((dest_file = FindFile(dest_file_path)) != NULL);
+  EXPECT_EQ(dest_file, FindFileByResource(src_file_resource));
+  EXPECT_EQ(src_file, dest_file);
+}
+
+TEST_F(GDataFileSystemTest, MoveFileFromRootToSubDirectory) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/File 1.txt"));
+  FilePath dest_parent_path(FILE_PATH_LITERAL("gdata/Directory 1"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Directory 1/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+  LoadSubdirFeedDocument(dest_parent_path, "subdir_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  GDataFileBase* dest_parent = NULL;
+  EXPECT_TRUE((dest_parent = FindFile(dest_parent_path)) != NULL);
+  EXPECT_TRUE(dest_parent->AsGDataDirectory() != NULL);
+  EXPECT_FALSE(dest_parent->content_url().is_empty());
+
+  EXPECT_CALL(*mock_doc_service_,
+              RenameResource(src_file->self_url(),
+                             FILE_PATH_LITERAL("Test.log"), _));
+  EXPECT_CALL(*mock_doc_service_,
+              AddResourceToDirectory(dest_parent->content_url(),
+                                     src_file->self_url(), _));
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
+
+  EXPECT_TRUE(FindFile(src_file_path) == NULL);
+
+  GDataFileBase* dest_file = NULL;
+  EXPECT_TRUE((dest_file = FindFile(dest_file_path)) != NULL);
+  EXPECT_EQ(dest_file, FindFileByResource(src_file_path_resource));
+  EXPECT_EQ(src_file, dest_file);
+}
+
+TEST_F(GDataFileSystemTest, MoveFileFromSubDirectoryToRoot) {
+  FilePath src_parent_path(FILE_PATH_LITERAL("gdata/Directory 1"));
+  FilePath src_file_path(
+      FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+  LoadSubdirFeedDocument(src_parent_path, "subdir_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  GDataFileBase* src_parent = NULL;
+  EXPECT_TRUE((src_parent = FindFile(src_parent_path)) != NULL);
+  EXPECT_TRUE(src_parent->AsGDataDirectory() != NULL);
+  EXPECT_FALSE(src_parent->content_url().is_empty());
+
+  EXPECT_CALL(*mock_doc_service_,
+              RenameResource(src_file->self_url(),
+                             FILE_PATH_LITERAL("Test.log"), _));
+  EXPECT_CALL(*mock_doc_service_,
+              RemoveResourceFromDirectory(src_parent->content_url(),
+                                          src_file->self_url(),
+                                          src_file_path_resource, _));
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
+
+  EXPECT_TRUE(FindFile(src_file_path) == NULL);
+
+  GDataFileBase* dest_file = NULL;
+  EXPECT_TRUE((dest_file = FindFile(dest_file_path)) != NULL);
+  EXPECT_EQ(dest_file, FindFileByResource(src_file_path_resource));
+  EXPECT_EQ(src_file, dest_file);
+}
+
+TEST_F(GDataFileSystemTest, MoveFileBetweenSubDirectories) {
+  FilePath src_parent_path(FILE_PATH_LITERAL("gdata/Directory 1"));
+  FilePath src_file_path(
+      FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt"));
+  FilePath dest_parent_path(FILE_PATH_LITERAL("gdata/New Folder 1"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/New Folder 1/Test.log"));
+  FilePath interim_file_path(FILE_PATH_LITERAL("gdata/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+  LoadSubdirFeedDocument(src_parent_path, "subdir_feed.json");
+  AddDirectoryFromFile(dest_parent_path, "directory_entry_atom.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  GDataFileBase* src_parent = NULL;
+  EXPECT_TRUE((src_parent = FindFile(src_parent_path)) != NULL);
+  EXPECT_TRUE(src_parent->AsGDataDirectory() != NULL);
+  EXPECT_FALSE(src_parent->content_url().is_empty());
+
+  GDataFileBase* dest_parent = NULL;
+  EXPECT_TRUE((dest_parent = FindFile(dest_parent_path)) != NULL);
+  EXPECT_TRUE(dest_parent->AsGDataDirectory() != NULL);
+  EXPECT_FALSE(dest_parent->content_url().is_empty());
+
+  EXPECT_TRUE(FindFile(interim_file_path) == NULL);
+
+  EXPECT_CALL(*mock_doc_service_,
+              RenameResource(src_file->self_url(),
+                             FILE_PATH_LITERAL("Test.log"), _));
+  EXPECT_CALL(*mock_doc_service_,
+              RemoveResourceFromDirectory(src_parent->content_url(),
+                                          src_file->self_url(),
+                                          src_file_path_resource, _));
+  EXPECT_CALL(*mock_doc_service_,
+              AddResourceToDirectory(dest_parent->content_url(),
+                                     src_file->self_url(), _));
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
+
+  EXPECT_TRUE(FindFile(src_file_path) == NULL);
+  EXPECT_TRUE(FindFile(interim_file_path) == NULL);
+
+  GDataFileBase* dest_file = NULL;
+  EXPECT_TRUE((dest_file = FindFile(dest_file_path)) != NULL);
+  EXPECT_EQ(dest_file, FindFileByResource(src_file_path_resource));
+  EXPECT_EQ(src_file, dest_file);
+}
+
+TEST_F(GDataFileSystemTest, MoveNotExistingFile) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/Dummy file.txt"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) == NULL);
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+
+  EXPECT_TRUE(FindFile(src_file_path) == NULL);
+  EXPECT_TRUE(FindFile(dest_file_path) == NULL);
+}
+
+TEST_F(GDataFileSystemTest, MoveFileToNonExistingDirectory) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/File 1.txt"));
+  FilePath dest_parent_path(FILE_PATH_LITERAL("gdata/Dummy"));
+  FilePath dest_file_path(FILE_PATH_LITERAL("gdata/Dummy/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  EXPECT_TRUE(FindFile(dest_parent_path) == NULL);
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+
+  EXPECT_EQ(src_file, FindFile(src_file_path));
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+
+  EXPECT_TRUE(FindFile(dest_parent_path) == NULL);
+  EXPECT_TRUE(FindFile(dest_file_path) == NULL);
+}
+
+// Test the case where the parent of |dest_file_path| is a existing file,
+// not a directory.
+TEST_F(GDataFileSystemTest, MoveFileToInvalidPath) {
+  FilePath src_file_path(FILE_PATH_LITERAL("gdata/File 1.txt"));
+  FilePath dest_parent_path(FILE_PATH_LITERAL("gdata/Duplicate Name.txt"));
+  FilePath dest_file_path(FILE_PATH_LITERAL(
+      "gdata/Duplicate Name.txt/Test.log"));
+
+  LoadRootFeedDocument("root_feed.json");
+
+  GDataFileBase* src_file = NULL;
+  EXPECT_TRUE((src_file = FindFile(src_file_path)) != NULL);
+  EXPECT_TRUE(src_file->AsGDataFile() != NULL);
+  std::string src_file_path_resource = src_file->AsGDataFile()->resource_id();
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_FALSE(src_file->self_url().is_empty());
+
+  GDataFileBase* dest_parent = NULL;
+  EXPECT_TRUE((dest_parent = FindFile(dest_parent_path)) != NULL);
+  EXPECT_TRUE(dest_parent->AsGDataFile() != NULL);
+
+  GDataFileSystem::FileOperationCallback callback =
+      base::Bind(&CallbackHelper::FileOperationCallback,
+                 callback_helper_.get());
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+  message_loop_.RunAllPending();  // Wait to get our result.
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
+            callback_helper_->last_error_);
+
+  EXPECT_EQ(src_file, FindFile(src_file_path));
+  EXPECT_EQ(src_file, FindFileByResource(src_file_path_resource));
+  EXPECT_EQ(dest_parent, FindFile(dest_parent_path));
+
+  EXPECT_TRUE(FindFile(dest_file_path) == NULL);
+}
+
 TEST_F(GDataFileSystemTest, RemoveFiles) {
   LoadRootFeedDocument("root_feed.json");
   LoadSubdirFeedDocument(FilePath(FILE_PATH_LITERAL("gdata/Directory 1")),
@@ -553,14 +989,14 @@
   GDataFileBase* file = NULL;
   EXPECT_TRUE((file = FindFile(file_in_root)) != NULL);
   EXPECT_TRUE(file->AsGDataFile() != NULL);
-  std::string file_in_root_resource = file->AsGDataFile()->resource();
+  std::string file_in_root_resource = file->AsGDataFile()->resource_id();
   EXPECT_EQ(file, FindFileByResource(file_in_root_resource));
 
   EXPECT_TRUE(FindFile(dir_in_root) != NULL);
 
   EXPECT_TRUE((file = FindFile(file_in_subdir)) != NULL);
   EXPECT_TRUE(file->AsGDataFile() != NULL);
-  std::string file_in_subdir_resource = file->AsGDataFile()->resource();
+  std::string file_in_subdir_resource = file->AsGDataFile()->resource_id();
   EXPECT_EQ(file, FindFileByResource(file_in_subdir_resource));
 
   // Remove first file in root.
@@ -761,12 +1197,13 @@
 
   // Store a file corresponding to resource and md5 of "gdata/File 1.txt" to
   // cache.
-  TestStoreToCache(file->resource(), file->file_md5(),
+  TestStoreToCache(file->resource_id(), file->file_md5(),
                    GetTestFilePath("root_feed.json"));
 
   // Now the file should exist in cache.
   cache_file_path = file_system_->GetFromCacheForPath(gdata_file_path);
-  EXPECT_EQ(file_system_->GetCacheFilePath(file->resource(), file->file_md5()),
+  EXPECT_EQ(file_system_->GetCacheFilePath(file->resource_id(),
+                                           file->file_md5()),
             cache_file_path);
 
   // A file that doesn't exist in gdata.