gdata: File info of dirty files should be get from the cached file.

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"
@@ skipping 337 matching lines @@
                                     GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   // Gets entry info by path synchronously.
   scoped_ptr<GDataEntryProto> GetEntryInfoByPathSync(
       const FilePath& file_path) {
     file_system_->GetEntryInfoByPath(
         file_path,
         base::Bind(&CallbackHelper::GetEntryInfoCallback,
                    callback_helper_.get()));
-    message_loop_.RunAllPending();
+    test_util::RunBlockingPoolTask();
 
     return callback_helper_->entry_proto_.Pass();
   }
 
   // Gets directory info by path synchronously.
   scoped_ptr<GDataEntryProtoVector> ReadDirectoryByPathSync(
       const FilePath& file_path) {
     file_system_->ReadDirectoryByPath(
         file_path,
         base::Bind(&CallbackHelper::ReadDirectoryCallback,
                    callback_helper_.get()));
-    message_loop_.RunAllPending();
+    test_util::RunBlockingPoolTask();
 
     return callback_helper_->directory_entries_.Pass();
   }
 
   // Returns true if an entry exists at |file_path|.
   bool EntryExists(const FilePath& file_path) {
     return GetEntryInfoByPathSync(file_path).get();
   }
 
 
@@ skipping 1000 matching lines @@
 
   LoadRootFeedDocument("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);
-  message_loop_.RunAllPending();  // Wait to get our result
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 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(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_path_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is a existing file,
 // not a directory.
 TEST_F(GDataFileSystemTest, CopyFileToInvalidPath) {
@@ skipping 15 matching lines @@
   ASSERT_TRUE(EntryExists(dest_parent_path));
   scoped_ptr<GDataEntryProto> 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);
-  message_loop_.RunAllPending();
+  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));
 }
 
@@ skipping 18 matching lines @@
                              FILE_PATH_LITERAL("Test.log"), _));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileFromRootToSubDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
@@ skipping 28 matching lines @@
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileFromSubDirectoryToRoot) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
@@ skipping 30 matching lines @@
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   ASSERT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveFileBetweenSubDirectories) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
@@ skipping 54 matching lines @@
   // Expect notification for both source and destination directories plus
   // interim file path.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/New Folder 1"))))).Times(1);
 
   file_system_->Move(src_file_path, dest_file_path, callback);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(interim_file_path));
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(GDataFileSystemTest, MoveNotExistingFile) {
   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");
 
   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);
-  message_loop_.RunAllPending();  // Wait to get our result
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 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(
       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);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is a existing file,
 // not a directory.
 TEST_F(GDataFileSystemTest, MoveFileToInvalidPath) {
@@ skipping 15 matching lines @@
   ASSERT_TRUE(EntryExists(dest_parent_path));
   scoped_ptr<GDataEntryProto> 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);
-  message_loop_.RunAllPending();
+  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");
@@ skipping 138 matching lines @@
       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<GDataFileError>(1);
   file_system_->CreateDirectory(
       FilePath(FILE_PATH_LITERAL("drive/Sample Directory Title")),
       false,  // is_exclusive
       true,  // is_recursive
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get()));
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   // TODO(gspencer): Uncomment this when we get a blob that
   // works that can be returned from the mock.
   // EXPECT_EQ(GDATA_FILE_OK, callback_helper_->last_error_);
 }
 
 TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
@@ skipping 516 matching lines @@
 }
 
 TEST_F(GDataFileSystemTest, GetAvailableSpace) {
   GetAvailableSpaceCallback callback =
       base::Bind(&CallbackHelper::GetAvailableSpaceCallback,
                  callback_helper_.get());
 
   EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_));
 
   file_system_->GetAvailableSpace(callback);
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
   EXPECT_EQ(GG_LONGLONG(6789012345), callback_helper_->quota_bytes_used_);
   EXPECT_EQ(GG_LONGLONG(9876543210), callback_helper_->quota_bytes_total_);
 }
 
 TEST_F(GDataFileSystemTest, RequestDirectoryRefresh) {
   LoadRootFeedDocument("root_feed.json");
 
   // We'll fetch documents in the root directory with its resource ID.
   EXPECT_CALL(*mock_doc_service_,
               GetDocuments(Eq(GURL()), _, _, kGDataRootDirectoryResourceId, _))
       .Times(1);
   // We'll notify the directory change to the observer.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kGDataRootDirectory)))).Times(1);
 
   file_system_->RequestDirectoryRefresh(FilePath(kGDataRootDirectory));
-  message_loop_.RunAllPending();
+  test_util::RunBlockingPoolTask();
 }
 
 TEST_F(GDataFileSystemTest, OpenAndCloseFile) {
   LoadRootFeedDocument("root_feed.json");
 
   OpenFileCallback callback =
       base::Bind(&CallbackHelper::OpenFileCallback,
                  callback_helper_.get());
   FileOperationCallback close_file_callback =
       base::Bind(&CallbackHelper::CloseFileCallback,
@@ skipping 73 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