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

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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 301 matching lines @@
     : public base::RefCountedThreadSafe<CallbackHelper> {
    public:
     CallbackHelper() : last_error_(base::PLATFORM_FILE_OK) {}
     virtual ~CallbackHelper() {}
     virtual void GetFileCallback(base::PlatformFileError error,
                                  const FilePath& file_path) {
       last_error_ = error;
       download_path_ = file_path;
     }
     virtual void FileOperationCallback(base::PlatformFileError error) {
+      DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
       last_error_ = error;
     }
 
     base::PlatformFileError last_error_;
     FilePath download_path_;
   };
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_ptr<TestingProfile> profile_;
@@ skipping 16 matching lines @@
 // Delegate used to find a directory element for file system updates.
 class MockFindFileDelegate : public gdata::FindFileDelegate {
  public:
   MockFindFileDelegate() {
   }
 
   virtual ~MockFindFileDelegate() {
   }
 
   // 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));
   MOCK_METHOD1(OnError, void(base::PlatformFileError));
 };
 
 TEST_F(GDataFileSystemTest, SearchRootDirectory) {
   scoped_refptr<MockFindFileDelegate> mock_find_file_delegate =
       new MockFindFileDelegate();
 
@@ skipping 163 matching lines @@
   LoadRootFeedDocument("root_feed.json");
   LoadSubdirFeedDocument(FilePath(FILE_PATH_LITERAL("gdata/Directory 1")),
                          "subdir_feed.json");
 
   FindAndTestFilePath(FilePath(FILE_PATH_LITERAL("gdata/File 1.txt")));
   FindAndTestFilePath(FilePath(FILE_PATH_LITERAL("gdata/Directory 1")));
   FindAndTestFilePath(
       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")),
                          "subdir_feed.json");
 
   FilePath nonexisting_file(FILE_PATH_LITERAL("gdata/Dummy file.txt"));
   FilePath file_in_root(FILE_PATH_LITERAL("gdata/File 1.txt"));
   FilePath dir_in_root(FILE_PATH_LITERAL("gdata/Directory 1"));
   FilePath file_in_subdir(
       FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt"));
 
   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.
   EXPECT_TRUE(RemoveFile(file_in_root));
   EXPECT_TRUE(FindFile(file_in_root) == NULL);
   EXPECT_EQ(NULL, FindFileByResource(file_in_root_resource));
   EXPECT_TRUE(FindFile(dir_in_root) != NULL);
   EXPECT_TRUE((file = FindFile(file_in_subdir)) != NULL);
   EXPECT_EQ(file, FindFileByResource(file_in_subdir_resource));
 
@@ skipping 180 matching lines @@
     file = file_info->AsGDataFile();
     ASSERT_TRUE(file != NULL);
   }
 
   // A file that exists in GData but not in cache.
   FilePath cache_file_path = file_system_->GetFromCacheForPath(gdata_file_path);
   EXPECT_TRUE(cache_file_path.empty());
 
   // 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.
   cache_file_path = file_system_->GetFromCacheForPath(
       FilePath(FILE_PATH_LITERAL("gdata/Nonexistent.txt")));
   EXPECT_TRUE(cache_file_path.empty());
 }
 
 // Create a directory through the document service
 TEST_F(GDataFileSystemTest, CreateDirectoryWithService) {
@@ skipping 39 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     profile_.reset(new TestingProfile);
     // TODO(kuan): Create some cache files to trigger scanning of cache dir,
     // and write tests to check the cache map.
     Init(profile_.get());
   }
 };
 
 }   // namespace gdata