Remove base::WorkerPool use from FileStream tests.

net/base/file_stream_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 "net/base/file_stream.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
+#include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
@@ skipping 15 matching lines @@
  public:
   virtual void SetUp() {
     PlatformTest::SetUp();
 
     file_util::CreateTemporaryFile(&temp_file_path_);
     file_util::WriteFile(temp_file_path_, kTestData, kTestDataSize);
   }
   virtual void TearDown() {
     EXPECT_TRUE(base::DeleteFile(temp_file_path_, false));
 
+    base::RunLoop().RunUntilIdle();

[Ryan Sleevi, 2013/09/06 23:27:28]

I'm not really thrilled with adding this to test shutdown.

In general, we should try to have our tests not leave tasks hanging. Is this
something you can go through and figure out what Tests need to pump tasks, and
pump them accordingly?

[I also have no clue why this test is using SetUp/TearDown, rather than just
doing this in the ctor/dtor as good GTests should do]

[earthdok, 2013/09/07 00:20:03]

The tasks are posted from async FileStreams on destruction. I have no problem
with adding a nested scope + pumping code to each async test if that's what you
prefer, but to me it's just unnecessary code duplication. This idiom (pumping
the MessageLoop in TearDown) is quite widespread anyway.

     PlatformTest::TearDown();
   }
 
   const base::FilePath temp_file_path() const { return temp_file_path_; }
 
+  scoped_refptr<base::TaskRunner> file_task_runner() const {
+    return base::MessageLoop::current()->message_loop_proxy();

[Ryan Sleevi, 2013/09/06 23:27:28]

Just drop this method and use base::MessageLoopProxy::current(), rather than
indirecting through the MessageLoop. (eg: updating 70 to take the
MLP::Current())

+  }
+
  private:
   base::FilePath temp_file_path_;
 };
 
 namespace {
 
 TEST_F(FileStreamTest, BasicOpenClose) {
   base::PlatformFile file = base::kInvalidPlatformFileValue;
   {
-    FileStream stream(NULL);
+    FileStream stream(NULL, file_task_runner());
     int rv = stream.OpenSync(temp_file_path(),
         base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(stream.IsOpen());
     file = stream.GetPlatformFileForTesting();
   }
   EXPECT_NE(base::kInvalidPlatformFileValue, file);
   base::PlatformFileInfo info;
   // The file should be closed.
   EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
 }
 
 TEST_F(FileStreamTest, FileHandleNotLeftOpen) {
   bool created = false;
   ASSERT_EQ(kTestDataSize,
       file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize));
   int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
   base::PlatformFile file = base::CreatePlatformFile(
       temp_file_path(), flags, &created, NULL);
 
   {
     // Seek to the beginning of the file and read.
-    FileStream read_stream(file, flags, NULL);
+    FileStream read_stream(file, flags, NULL, file_task_runner());
     EXPECT_TRUE(read_stream.IsOpen());
   }
 
   EXPECT_NE(base::kInvalidPlatformFileValue, file);
   base::PlatformFileInfo info;
   // The file should be closed.
   EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
 }
 
 // Test the use of FileStream with a file handle provided at construction.
 TEST_F(FileStreamTest, UseFileHandle) {
   bool created = false;
 
   // 1. Test reading with a file handle.
   ASSERT_EQ(kTestDataSize,
       file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize));
   int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
   base::PlatformFile file = base::CreatePlatformFile(
       temp_file_path(), flags, &created, NULL);
 
   // Seek to the beginning of the file and read.
-  scoped_ptr<FileStream> read_stream(new FileStream(file, flags, NULL));
+  scoped_ptr<FileStream> read_stream(
+      new FileStream(file, flags, NULL, file_task_runner()));
   ASSERT_EQ(0, read_stream->SeekSync(FROM_BEGIN, 0));
   ASSERT_EQ(kTestDataSize, read_stream->Available());
   // Read into buffer and compare.
   char buffer[kTestDataSize];
   ASSERT_EQ(kTestDataSize,
             read_stream->ReadSync(buffer, kTestDataSize));
   ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize));
   read_stream.reset();
 
   // 2. Test writing with a file handle.
   base::DeleteFile(temp_file_path(), false);
   flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE;
   file = base::CreatePlatformFile(temp_file_path(), flags, &created, NULL);
 
-  scoped_ptr<FileStream> write_stream(new FileStream(file, flags, NULL));
+  scoped_ptr<FileStream> write_stream(
+      new FileStream(file, flags, NULL, file_task_runner()));
   ASSERT_EQ(0, write_stream->SeekSync(FROM_BEGIN, 0));
   ASSERT_EQ(kTestDataSize,
             write_stream->WriteSync(kTestData, kTestDataSize));
   write_stream.reset();
 
   // Read into buffer and compare to make sure the handle worked fine.
   ASSERT_EQ(kTestDataSize,
       file_util::ReadFile(temp_file_path(), buffer, kTestDataSize));
   ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize));
 }
 
 TEST_F(FileStreamTest, UseClosedStream) {
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
 
   EXPECT_FALSE(stream.IsOpen());
 
   // Try seeking...
   int64 new_offset = stream.SeekSync(FROM_BEGIN, 5);
   EXPECT_EQ(ERR_UNEXPECTED, new_offset);
 
   // Try available...
   int64 avail = stream.Available();
   EXPECT_EQ(ERR_UNEXPECTED, avail);
 
   // Try reading...
   char buf[10];
   int rv = stream.ReadSync(buf, arraysize(buf));
   EXPECT_EQ(ERR_UNEXPECTED, rv);
 }
 
 TEST_F(FileStreamTest, BasicRead) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
   int rv = stream.OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   int64 total_bytes_avail = stream.Available();
   EXPECT_EQ(file_size, total_bytes_avail);
 
   int total_bytes_read = 0;
 
   std::string data_read;
   for (;;) {
     char buf[4];
     rv = stream.ReadSync(buf, arraysize(buf));
     EXPECT_LE(0, rv);
     if (rv <= 0)
       break;
     total_bytes_read += rv;
     data_read.append(buf, rv);
   }
   EXPECT_EQ(file_size, total_bytes_read);
   EXPECT_EQ(kTestData, data_read);
 }
 
 TEST_F(FileStreamTest, AsyncRead) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream.Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   int64 total_bytes_avail = stream.Available();
   EXPECT_EQ(file_size, total_bytes_avail);
@@ skipping 14 matching lines @@
   }
   EXPECT_EQ(file_size, total_bytes_read);
   EXPECT_EQ(kTestData, data_read);
 }
 
 TEST_F(FileStreamTest, AsyncRead_EarlyDelete) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream->Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   int64 total_bytes_avail = stream->Available();
   EXPECT_EQ(file_size, total_bytes_avail);
 
   scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
   rv = stream->Read(buf.get(), buf->size(), callback.callback());
   stream.reset();  // Delete instead of closing it.
   if (rv < 0) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
     // The callback should not be called if the request is cancelled.
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(callback.have_result());
   } else {
     EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv));
   }
 }
 
 TEST_F(FileStreamTest, BasicRead_FromOffset) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
   int rv = stream.OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   const int64 kOffset = 3;
   int64 new_offset = stream.SeekSync(FROM_BEGIN, kOffset);
   EXPECT_EQ(kOffset, new_offset);
 
   int64 total_bytes_avail = stream.Available();
@@ skipping 14 matching lines @@
   EXPECT_EQ(file_size - kOffset, total_bytes_read);
   EXPECT_TRUE(data_read == kTestData + kOffset);
   EXPECT_EQ(kTestData + kOffset, data_read);
 }
 
 TEST_F(FileStreamTest, AsyncRead_FromOffset) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream.Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   TestInt64CompletionCallback callback64;
   const int64 kOffset = 3;
@@ skipping 17 matching lines @@
     if (rv <= 0)
       break;
     total_bytes_read += rv;
     data_read.append(buf->data(), rv);
   }
   EXPECT_EQ(file_size - kOffset, total_bytes_read);
   EXPECT_EQ(kTestData + kOffset, data_read);
 }
 
 TEST_F(FileStreamTest, SeekAround) {
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
   int rv = stream.OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   const int64 kOffset = 3;
   int64 new_offset = stream.SeekSync(FROM_BEGIN, kOffset);
   EXPECT_EQ(kOffset, new_offset);
 
   new_offset = stream.SeekSync(FROM_CURRENT, kOffset);
   EXPECT_EQ(2 * kOffset, new_offset);
 
   new_offset = stream.SeekSync(FROM_CURRENT, -kOffset);
   EXPECT_EQ(kOffset, new_offset);
 
   const int kTestDataLen = arraysize(kTestData) - 1;
 
   new_offset = stream.SeekSync(FROM_END, -kTestDataLen);
   EXPECT_EQ(0, new_offset);
 }
 
 TEST_F(FileStreamTest, AsyncSeekAround) {
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_ASYNC |
               base::PLATFORM_FILE_READ;
   TestCompletionCallback callback;
   int rv = stream.Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   TestInt64CompletionCallback callback64;
 
@@ skipping 15 matching lines @@
 
   const int kTestDataLen = arraysize(kTestData) - 1;
 
   rv = stream.Seek(FROM_END, -kTestDataLen, callback64.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   new_offset = callback64.WaitForResult();
   EXPECT_EQ(0, new_offset);
 }
 
 TEST_F(FileStreamTest, BasicWrite) {
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
               base::PLATFORM_FILE_WRITE;
   int rv = stream->OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(0, file_size);
 
   rv = stream->WriteSync(kTestData, kTestDataSize);
   EXPECT_EQ(kTestDataSize, rv);
   stream.reset();
 
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kTestDataSize, file_size);
 }
 
 TEST_F(FileStreamTest, AsyncWrite) {
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream.Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
@@ skipping 15 matching lines @@
       break;
     drainable->DidConsume(rv);
     total_bytes_written += rv;
   }
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(file_size, total_bytes_written);
 }
 
 TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) {
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream->Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(0, file_size);
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
   rv = stream->Write(buf.get(), buf->size(), callback.callback());
   stream.reset();
   if (rv < 0) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
     // The callback should not be called if the request is cancelled.
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(callback.have_result());
   } else {
     ok = file_util::GetFileSize(temp_file_path(), &file_size);
     EXPECT_TRUE(ok);
     EXPECT_EQ(file_size, rv);
   }
 }
 
 TEST_F(FileStreamTest, BasicWrite_FromOffset) {
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_WRITE;
   int rv = stream->OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kTestDataSize, file_size);
 
   const int64 kOffset = 0;
   int64 new_offset = stream->SeekSync(FROM_END, kOffset);
   EXPECT_EQ(kTestDataSize, new_offset);
 
   rv = stream->WriteSync(kTestData, kTestDataSize);
   EXPECT_EQ(kTestDataSize, rv);
   stream.reset();
 
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kTestDataSize * 2, file_size);
 }
 
 TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  FileStream stream(NULL);
+  FileStream stream(NULL, file_task_runner());
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream.Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   TestInt64CompletionCallback callback64;
   const int64 kOffset = 0;
@@ skipping 21 matching lines @@
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(file_size, kTestDataSize * 2);
 }
 
 TEST_F(FileStreamTest, BasicReadWrite) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE;
   int rv = stream->OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   int64 total_bytes_avail = stream->Available();
   EXPECT_EQ(file_size, total_bytes_avail);
 
   int total_bytes_read = 0;
@@ skipping 18 matching lines @@
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kTestDataSize * 2, file_size);
 }
 
 TEST_F(FileStreamTest, BasicWriteRead) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE;
   int rv = stream->OpenSync(temp_file_path(), flags);
   EXPECT_EQ(OK, rv);
 
   int64 total_bytes_avail = stream->Available();
   EXPECT_EQ(file_size, total_bytes_avail);
 
   int64 offset = stream->SeekSync(FROM_END, 0);
@@ skipping 27 matching lines @@
   const std::string kExpectedFileData =
       std::string(kTestData) + std::string(kTestData);
   EXPECT_EQ(kExpectedFileData, data_read);
 }
 
 TEST_F(FileStreamTest, BasicAsyncReadWrite) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream->Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   int64 total_bytes_avail = stream->Available();
@@ skipping 38 matching lines @@
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kTestDataSize * 2, file_size);
 }
 
 TEST_F(FileStreamTest, BasicAsyncWriteRead) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream->Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   int64 total_bytes_avail = stream->Available();
@@ skipping 70 matching lines @@
         data_read_(data_read),
         callback_(base::Bind(&TestWriteReadCompletionCallback::OnComplete,
                              base::Unretained(this))),
         test_data_(CreateTestDataBuffer()),
         drainable_(new DrainableIOBuffer(test_data_.get(), kTestDataSize)) {}
 
   int WaitForResult() {
     DCHECK(!waiting_for_result_);
     while (!have_result_) {
       waiting_for_result_ = true;
-      base::MessageLoop::current()->Run();
+      base::RunLoop().Run();
       waiting_for_result_ = false;
     }
     have_result_ = false;  // auto-reset for next callback
     return result_;
   }
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result) {
@@ skipping 54 matching lines @@
   scoped_refptr<DrainableIOBuffer> drainable_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWriteReadCompletionCallback);
 };
 
 TEST_F(FileStreamTest, AsyncWriteRead) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback open_callback;
   int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, open_callback.WaitForResult());
 
   int64 total_bytes_avail = stream->Available();
@@ skipping 37 matching lines @@
         total_bytes_written_(total_bytes_written),
         callback_(base::Bind(&TestWriteCloseCompletionCallback::OnComplete,
                              base::Unretained(this))),
         test_data_(CreateTestDataBuffer()),
         drainable_(new DrainableIOBuffer(test_data_.get(), kTestDataSize)) {}
 
   int WaitForResult() {
     DCHECK(!waiting_for_result_);
     while (!have_result_) {
       waiting_for_result_ = true;
-      base::MessageLoop::current()->Run();
+      base::RunLoop().Run();
       waiting_for_result_ = false;
     }
     have_result_ = false;  // auto-reset for next callback
     return result_;
   }
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result) {
@@ skipping 30 matching lines @@
   scoped_refptr<DrainableIOBuffer> drainable_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWriteCloseCompletionCallback);
 };
 
 TEST_F(FileStreamTest, AsyncWriteClose) {
   int64 file_size;
   bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
 
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback open_callback;
   int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, open_callback.WaitForResult());
 
   int64 total_bytes_avail = stream->Available();
@@ skipping 16 matching lines @@
 
   ok = file_util::GetFileSize(temp_file_path(), &file_size);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kTestDataSize * 2, file_size);
 }
 
 // Tests truncating a file.
 TEST_F(FileStreamTest, Truncate) {
   int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE;
 
-  scoped_ptr<FileStream> write_stream(new FileStream(NULL));
+  scoped_ptr<FileStream> write_stream(new FileStream(NULL, file_task_runner()));
   ASSERT_EQ(OK, write_stream->OpenSync(temp_file_path(), flags));
 
   // Write some data to the file.
   const char test_data[] = "0123456789";
   write_stream->WriteSync(test_data, arraysize(test_data));
 
   // Truncate the file.
   ASSERT_EQ(4, write_stream->Truncate(4));
 
   // Write again.
   write_stream->WriteSync(test_data, 4);
 
   // Close the stream.
   write_stream.reset();
 
   // Read in the contents and make sure we get back what we expected.
   std::string read_contents;
   EXPECT_TRUE(base::ReadFileToString(temp_file_path(), &read_contents));
 
   EXPECT_EQ("01230123", read_contents);
 }
 
 TEST_F(FileStreamTest, AsyncOpenAndDelete) {
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
       base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback open_callback;
   int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Delete the stream without waiting for the open operation to be
   // complete. Should be safe.
   stream.reset();
   // open_callback won't be called.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(open_callback.have_result());
 }
 
 // Verify that async Write() errors are mapped correctly.
 TEST_F(FileStreamTest, AsyncWriteError) {
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream->Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Try passing NULL buffer to Write() and check that it fails.
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(NULL);
   rv = stream->Write(buf.get(), 1, callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_LT(rv, 0);
 }
 
 // Verify that async Read() errors are mapped correctly.
 TEST_F(FileStreamTest, AsyncReadError) {
-  scoped_ptr<FileStream> stream(new FileStream(NULL));
+  scoped_ptr<FileStream> stream(new FileStream(NULL, file_task_runner()));
   int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
   TestCompletionCallback callback;
   int rv = stream->Open(temp_file_path(), flags, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Try passing NULL buffer to Read() and check that it fails.
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(NULL);
   rv = stream->Read(buf.get(), 1, callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_LT(rv, 0);
 }
 
 }  // namespace
 
 }  // namespace net