Removed few methods from CallbackHelper in drive_file_system_unittest.cc

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 340 matching lines @@
                                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) {
+    DriveFileError error;
+    scoped_ptr<DriveEntryProto> entry_proto;
     file_system_->GetEntryInfoByPath(
         file_path,
-        base::Bind(&CallbackHelper::GetEntryInfoCallback,
-                   callback_helper_.get()));
+        base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                   &error, &entry_proto));
     google_apis::test_util::RunBlockingPoolTask();
 
-    return callback_helper_->entry_proto_.Pass();
+    return 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()));
     google_apis::test_util::RunBlockingPoolTask();
@@ skipping 373 matching lines @@
     virtual void GetFileCallback(DriveFileError error,
                                  const FilePath& file_path,
                                  const std::string& mime_type,
                                  DriveFileType file_type) {
       last_error_ = error;
       download_path_ = file_path;
       mime_type_ = mime_type;
       file_type_ = file_type;
     }
 
-    virtual void FileOperationCallback(DriveFileError error) {
-      DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-      last_error_ = error;
-    }
-
     virtual void GetAvailableSpaceCallback(DriveFileError error,
                                            int64 bytes_total,
                                            int64 bytes_used) {
       last_error_ = error;
       quota_bytes_total_ = bytes_total;
       quota_bytes_used_ = bytes_used;
     }
 
     virtual void OpenFileCallback(DriveFileError error,
                                   const FilePath& file_path) {
       last_error_ = error;
       opened_file_path_ = file_path;
       MessageLoop::current()->Quit();
     }
 
     virtual void CloseFileCallback(DriveFileError error) {
       last_error_ = error;
       MessageLoop::current()->Quit();
     }
 
-    virtual void GetEntryInfoCallback(
-        DriveFileError error,
-        scoped_ptr<DriveEntryProto> entry_proto) {
-      last_error_ = error;
-      entry_proto_ = entry_proto.Pass();
-    }
-
     virtual void ReadDirectoryCallback(
         DriveFileError error,
         bool /* hide_hosted_documents */,
         scoped_ptr<DriveEntryProtoVector> entries) {
       last_error_ = error;
       directory_entries_ = entries.Pass();
     }
 
     DriveFileError last_error_;
     FilePath download_path_;
@@ skipping 458 matching lines @@
 
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(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.
   base::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 =
       google_apis::test_util::LoadJSONFile("gdata/document_to_download.json");
   scoped_ptr<google_apis::ResourceEntry> resource_entry(
       google_apis::ResourceEntry::ExtractAndParse(*value));
 
   // Transfer the local file to Drive.
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromLocalToRemote(
-      local_src_file_path, remote_dest_file_path, callback);
+      local_src_file_path,
+      remote_dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument("gdata/root_feed.json"));
 
   // Prepare a local file, which is a json file of a hosted document, which
   // matches "Document 1" in root_feed.json.
@@ skipping 26 matching lines @@
   EXPECT_CALL(*mock_drive_service_,
               CopyHostedDocument(kResourceId,
                                  FILE_PATH_LITERAL("Document 1"),
                                  _))
       .WillOnce(MockCopyHostedDocument(google_apis::HTTP_SUCCESS,
                                        &resource_entry));
   // 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.
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromLocalToRemote(
-      local_src_file_path, remote_dest_file_path, callback);
+      local_src_file_path,
+      remote_dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
   ASSERT_TRUE(LoadRootFeedDocument("gdata/root_feed.json"));
 
-  FileOperationCallback callback =
-      base::Bind(&CallbackHelper::FileOperationCallback,
-                 callback_helper_.get());
-
   base::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<DriveEntryProto> file = GetEntryInfoByPathSync(
       remote_src_file_path);
   FilePath cache_file = GetCachePathForFile(
       file->resource_id(),
       file->file_specific_info().file_md5());
@@ skipping 13 matching lines @@
   SetExpectationsForGetResourceEntry(*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);
 
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromRemoteToLocal(
-      remote_src_file_path, local_dest_file_path, callback);
+      remote_src_file_path,
+      local_dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, 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) {
   ASSERT_TRUE(LoadRootFeedDocument("gdata/root_feed.json"));
 
-  FileOperationCallback callback =
-      base::Bind(&CallbackHelper::FileOperationCallback,
-                 callback_helper_.get());
-
   base::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"));
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromRemoteToLocal(
-      remote_src_file_path, local_dest_file_path, callback);
+      remote_src_file_path,
+      local_dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, 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"));
 
   ASSERT_TRUE(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);
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->Copy(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, 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"));
 
   ASSERT_TRUE(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());
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
 
-  file_system_->Move(src_file_path, dest_file_path, callback);
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, 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) {
   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"));
 
   ASSERT_TRUE(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());
 
   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);
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->Copy(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY,
-            callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY, 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(DriveFileSystemTest, 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"));
 
   ASSERT_TRUE(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_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              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);
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, 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"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
@@ skipping 16 matching lines @@
   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(
                   GURL(dest_parent_proto->content_url()),
                   GURL(src_entry_proto->edit_url()), _));
 
-  FileOperationCallback callback =
-      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);
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, 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(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
@@ skipping 17 matching lines @@
   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(
                   GURL(src_parent_proto->content_url()),
                   src_file_resource_id, _));
 
-  FileOperationCallback callback =
-      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);
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, 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(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
@@ skipping 38 matching lines @@
   EXPECT_CALL(*mock_drive_service_,
               RemoveResourceFromDirectory(
                   GURL(src_parent_proto->content_url()),
                   src_file_resource_id, _));
   EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(
                   GURL(dest_parent_proto->content_url()),
                   GURL(src_entry_proto->edit_url()),
                   _));
 
-  FileOperationCallback callback =
-      base::Bind(&CallbackHelper::FileOperationCallback,
-                 callback_helper_.get());
-
   // 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);
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_OK, 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"));
 
   ASSERT_TRUE(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);
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, 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"));
 
   ASSERT_TRUE(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);
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
-
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, 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) {
   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"));
 
   ASSERT_TRUE(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());
 
   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);
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->Move(
+      src_file_path,
+      dest_file_path,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY,
-            callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY, error);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, RemoveEntries) {
   ASSERT_TRUE(LoadRootFeedDocument("gdata/root_feed.json"));
 
   FilePath nonexisting_file(FILE_PATH_LITERAL("drive/Dummy file.txt"));
@@ skipping 129 matching lines @@
 }
 
 // Create a directory through the document service
 TEST_F(DriveFileSystemTest, CreateDirectoryWithService) {
   ASSERT_TRUE(LoadRootFeedDocument("gdata/root_feed.json"));
   EXPECT_CALL(*mock_drive_service_,
               AddNewDirectory(_, "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);
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
       FilePath(FILE_PATH_LITERAL("drive/Sample Directory Title")),
       false,  // is_exclusive
       true,  // is_recursive
-      base::Bind(&CallbackHelper::FileOperationCallback,
-                 callback_helper_.get()));
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::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_);
+
+  EXPECT_EQ(DRIVE_FILE_OK, error);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   ASSERT_TRUE(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"));
@@ skipping 402 matching lines @@
       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));
 
   // We'll notify the directory change to the observer upon completion.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kDriveRootDirectory)))).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<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);
+  // The callback will be called upon completion of
+  // UpdateFileByResourceId().
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  file_system_->UpdateFileByResourceId(
+      kResourceId,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
 
-  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) {
   ASSERT_TRUE(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);
+  DriveFileError error = DRIVE_FILE_OK;
+  file_system_->UpdateFileByResourceId(
+      kResourceId,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
   google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 }
 
 TEST_F(DriveFileSystemTest, ContentSearch) {
   ASSERT_TRUE(LoadRootFeedDocument("gdata/root_feed.json"));
 
   mock_drive_service_->set_search_result("gdata/search_result_feed.json");
 
   // There should be only one GetResourceList request, even though search result
   // feed has next feed url.
   EXPECT_CALL(*mock_drive_service_, GetResourceList(Eq(GURL()), _, "foo", _, _,
@@ skipping 223 matching lines @@
 
   // An app for foo.ext_1 should now be found, as the registry was loaded.
   drive_webapps_registry_->GetWebAppsForFile(
       FilePath(FILE_PATH_LITERAL("foo.ext_1")),
       "" /* mime_type */,
       &apps);
   EXPECT_EQ(1U, apps.size());
 }
 
 }   // namespace drive