The ReadFile API on Windows invoked by the FileStream::Context class which is used by URLRequestFil…

chrome/browser/sync_file_system/local/syncable_file_operation_runner_unittest.cc

 // Copyright 2013 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 "base/basictypes.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_status.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/local/syncable_file_operation_runner.h"
 #include "chrome/browser/sync_file_system/local/syncable_file_system_operation.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "content/public/test/mock_blob_url_request_context.h"
@@ skipping 101 matching lines @@
     write_bytes_ += bytes;
     write_complete_ = complete;
     ++callback_count_;
   }
 
   void DidFinish(const tracked_objects::Location& location,
                  File::Error expect, File::Error status) {
     SCOPED_TRACE(testing::Message() << location.ToString());
     EXPECT_EQ(expect, status);
     ++callback_count_;
+    base::MessageLoop::current()->Quit();
   }
 
   bool CreateTempFile(base::FilePath* path) {
     return base::CreateTemporaryFileInDir(dir_.path(), path);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   base::ScopedTempDir dir_;
   scoped_ptr<leveldb::Env> in_memory_env_;
@@ skipping 19 matching lines @@
   ASSERT_FALSE(sync_status()->IsWritable(URL(kFile)));
 
   // The URL is in syncing so the write operations won't run.
   ResetCallbackStatus();
   file_system_.operation_runner()->CreateFile(
       URL(kFile), false /* exclusive */,
       ExpectStatus(FROM_HERE, File::FILE_OK));
   file_system_.operation_runner()->Truncate(
       URL(kFile), 1,
       ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, callback_count_);
 
   // Read operations are not blocked (and are executed before queued ones).
   file_system_.operation_runner()->FileExists(
       URL(kFile), ExpectStatus(FROM_HERE, File::FILE_ERROR_NOT_FOUND));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
 
   // End syncing (to enable write).
   sync_status()->EndSyncing(URL(kFile));
   ASSERT_TRUE(sync_status()->IsWritable(URL(kFile)));
 
   ResetCallbackStatus();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, callback_count_);
 
   // Now the file must have been created and updated.
   ResetCallbackStatus();
   file_system_.operation_runner()->FileExists(
       URL(kFile), ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
 }
 
 TEST_F(SyncableFileOperationRunnerTest, WriteToParentAndChild) {
   // First create the kDir directory and kChild in the dir.
   EXPECT_EQ(File::FILE_OK, file_system_.CreateDirectory(URL(kDir)));
   EXPECT_EQ(File::FILE_OK, file_system_.CreateFile(URL(kChild)));
 
   // Start syncing the kDir directory.
   sync_status()->StartSyncing(URL(kDir));
   ASSERT_FALSE(sync_status()->IsWritable(URL(kDir)));
 
   // Writes to kParent and kChild should be all queued up.
   ResetCallbackStatus();
   file_system_.operation_runner()->Truncate(
       URL(kChild), 1, ExpectStatus(FROM_HERE, File::FILE_OK));
   file_system_.operation_runner()->Remove(
       URL(kParent), true /* recursive */,
       ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, callback_count_);
 
   // Read operations are not blocked (and are executed before queued ones).
   file_system_.operation_runner()->DirectoryExists(
       URL(kDir), ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(1, callback_count_);
 
   // Writes to unrelated files must succeed as well.
   ResetCallbackStatus();
   file_system_.operation_runner()->CreateDirectory(
       URL(kOther), false /* exclusive */, false /* recursive */,
       ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(1, callback_count_);
 
   // End syncing (to enable write).
   sync_status()->EndSyncing(URL(kDir));
   ASSERT_TRUE(sync_status()->IsWritable(URL(kDir)));
 
   ResetCallbackStatus();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(2, callback_count_);
 }
 
 TEST_F(SyncableFileOperationRunnerTest, CopyAndMove) {
   // First create the kDir directory and kChild in the dir.
   EXPECT_EQ(File::FILE_OK, file_system_.CreateDirectory(URL(kDir)));
   EXPECT_EQ(File::FILE_OK, file_system_.CreateFile(URL(kChild)));
 
   // Start syncing the kParent directory.
   sync_status()->StartSyncing(URL(kParent));
 
   // Copying kDir to other directory should succeed, while moving would fail
   // (since the source directory is in syncing).
   ResetCallbackStatus();
   file_system_.operation_runner()->Copy(
       URL(kDir),
       URL("dest-copy"),
       storage::FileSystemOperation::OPTION_NONE,
       storage::FileSystemOperationRunner::CopyProgressCallback(),
       ExpectStatus(FROM_HERE, File::FILE_OK));
   file_system_.operation_runner()->Move(
       URL(kDir),
       URL("dest-move"),
       storage::FileSystemOperation::OPTION_NONE,
       ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(1, callback_count_);
 
   // Only "dest-copy1" should exist.
   EXPECT_EQ(File::FILE_OK,
             file_system_.DirectoryExists(URL("dest-copy")));
   EXPECT_EQ(File::FILE_ERROR_NOT_FOUND,
             file_system_.DirectoryExists(URL("dest-move")));
 
   // Start syncing the "dest-copy2" directory.
   sync_status()->StartSyncing(URL("dest-copy2"));
 
   // Now the destination is also locked copying kDir should be queued.
   ResetCallbackStatus();
   file_system_.operation_runner()->Copy(
       URL(kDir),
       URL("dest-copy2"),
       storage::FileSystemOperation::OPTION_NONE,
       storage::FileSystemOperationRunner::CopyProgressCallback(),
       ExpectStatus(FROM_HERE, File::FILE_OK));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, callback_count_);
 
   // Finish syncing the "dest-copy2" directory to unlock Copy.
   sync_status()->EndSyncing(URL("dest-copy2"));
   ResetCallbackStatus();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(1, callback_count_);
 
   // Now we should have "dest-copy2".
   EXPECT_EQ(File::FILE_OK,
             file_system_.DirectoryExists(URL("dest-copy2")));
 
   // Finish syncing the kParent to unlock Move.
   sync_status()->EndSyncing(URL(kParent));
   ResetCallbackStatus();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(1, callback_count_);
 
   // Now we should have "dest-move".
   EXPECT_EQ(File::FILE_OK,
             file_system_.DirectoryExists(URL("dest-move")));
 }
 
 TEST_F(SyncableFileOperationRunnerTest, Write) {
   EXPECT_EQ(File::FILE_OK, file_system_.CreateFile(URL(kFile)));
   const std::string kData("Lorem ipsum.");
   ScopedTextBlob blob(url_request_context_, "blob:foo", kData);
 
   sync_status()->StartSyncing(URL(kFile));
 
   ResetCallbackStatus();
   file_system_.operation_runner()->Write(
       &url_request_context_,
       URL(kFile), blob.GetBlobDataHandle(), 0, GetWriteCallback(FROM_HERE));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, callback_count_);
 
   sync_status()->EndSyncing(URL(kFile));
   ResetCallbackStatus();
 
   while (!write_complete_)
     base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(File::FILE_OK, write_status_);
   EXPECT_EQ(kData.size(), write_bytes_);
@@ skipping 69 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
 
   // Run Truncate and immediately cancel. This shouldn't crash.
   ResetCallbackStatus();
   storage::FileSystemOperationRunner::OperationID id =
       file_system_.operation_runner()->Truncate(
           URL(kFile), 10, ExpectStatus(FROM_HERE, File::FILE_OK));
   file_system_.operation_runner()->Cancel(
       id, ExpectStatus(FROM_HERE, File::FILE_ERROR_INVALID_OPERATION));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().Run();
   EXPECT_EQ(2, callback_count_);
 }
 
 }  // namespace sync_file_system