Remove calls to deprecated MessageLoop methods in content.

content/browser/byte_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 "content/browser/byte_stream.h"
 
 #include <stddef.h>
 
 #include <deque>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
+#include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
 void CountCallbacks(int* counter) {
   ++*counter;
 }
@@ skipping 86 matching lines @@
   // Push a series of IO buffers on; test pushback happening and
   // that it's advisory.
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
   EXPECT_FALSE(Write(byte_stream_input.get(), 1));
   EXPECT_FALSE(Write(byte_stream_input.get(), 1024));
   // Flush
   byte_stream_input->Close(0);
   EXPECT_EQ(4 * 1024U + 1U, byte_stream_input->GetTotalBufferedBytes());
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // Data already sent to reader is also counted in.
   EXPECT_EQ(4 * 1024U + 1U, byte_stream_input->GetTotalBufferedBytes());
 
   // Pull the IO buffers out; do we get the same buffers and do they
   // have the same contents?
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
@@ skipping 10 matching lines @@
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // Reader now knows that all data is read out.
   EXPECT_EQ(1024U, byte_stream_input->GetTotalBufferedBytes());
 }
 
 // Confirm that Flush() method makes the writer to send written contents to
 // the reader.
 TEST_F(ByteStreamTest, ByteStream_Flush) {
   std::unique_ptr<ByteStreamWriter> byte_stream_input;
   std::unique_ptr<ByteStreamReader> byte_stream_output;
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    1024, &byte_stream_input, &byte_stream_output);
 
   EXPECT_TRUE(Write(byte_stream_input.get(), 1));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length = 0;
   // Check that data is not sent to the reader yet.
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 
   byte_stream_input->Flush();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   // Check that it's ok to Flush() an empty writer.
   byte_stream_input->Flush();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 
   byte_stream_input->Close(0);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 }
 
 // Same as above, only use knowledge of the internals to confirm
 // that we're getting pushback even when data's split across the two
 // objects
 TEST_F(ByteStreamTest, ByteStream_PushBackSplit) {
   std::unique_ptr<ByteStreamWriter> byte_stream_input;
   std::unique_ptr<ByteStreamReader> byte_stream_output;
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    9 * 1024, &byte_stream_input, &byte_stream_output);
 
   // Push a series of IO buffers on; test pushback happening and
   // that it's advisory.
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(Write(byte_stream_input.get(), 6 * 1024));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Pull the IO buffers out; do we get the same buffers and do they
   // have the same contents?
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
@@ skipping 24 matching lines @@
 
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
 
   // Empty stream, non-error case.
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    3 * 1024, &byte_stream_input, &byte_stream_output);
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   byte_stream_input->Close(0);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_EQ(0, byte_stream_output->GetStatus());
 
   // Non-empty stream, non-error case.
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    3 * 1024, &byte_stream_input, &byte_stream_output);
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
   byte_stream_input->Close(0);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
   ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_EQ(0, byte_stream_output->GetStatus());
 
   const int kFakeErrorCode = 22;
 
   // Empty stream, error case.
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    3 * 1024, &byte_stream_input, &byte_stream_output);
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   byte_stream_input->Close(kFakeErrorCode);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_EQ(kFakeErrorCode, byte_stream_output->GetStatus());
 
   // Non-empty stream, error case.
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    3 * 1024, &byte_stream_input, &byte_stream_output);
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(Write(byte_stream_input.get(), 1024));
   byte_stream_input->Close(kFakeErrorCode);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
   ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_EQ(kFakeErrorCode, byte_stream_output->GetStatus());
 }
 
 // Confirm that callbacks on the sink side are triggered when they should be.
 TEST_F(ByteStreamTest, ByteStream_SinkCallback) {
@@ skipping 14 matching lines @@
   // tests below should get much more precise.
 
   // Confirm callback called when you add more than 33% of the buffer.
 
   // Setup callback
   int num_callbacks = 0;
   byte_stream_output->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
 
   EXPECT_TRUE(Write(byte_stream_input.get(), 4000));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, num_callbacks);
   task_runner->RunUntilIdle();
   EXPECT_EQ(1, num_callbacks);
 
   // Check data and stream state.
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 
   // Confirm callback *isn't* called at less than 33% (by lack of
   // unexpected call on task runner).
   EXPECT_TRUE(Write(byte_stream_input.get(), 3000));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // This reflects an implementation artifact that data goes with callbacks,
   // which should not be considered part of the interface guarantee.
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 }
 
 // Confirm that callbacks on the source side are triggered when they should
 // be.
 TEST_F(ByteStreamTest, ByteStream_SourceCallback) {
@@ skipping 19 matching lines @@
   // Add data.
   int num_callbacks = 0;
   byte_stream_input->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
   EXPECT_TRUE(Write(byte_stream_input.get(), 2000));
   EXPECT_TRUE(Write(byte_stream_input.get(), 2001));
   EXPECT_FALSE(Write(byte_stream_input.get(), 6000));
 
   // Allow bytes to transition (needed for message passing implementation),
   // and get and validate the data.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   // Grab data, triggering callback.  Recorded on dispatch, but doesn't
   // happen because it's caught by the mock.
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
@@ skipping 30 matching lines @@
   size_t output_length;
   base::Closure intermediate_callback;
 
   // Record initial state.
   int num_callbacks = 0;
   byte_stream_output->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
 
   // Add data, and pass it across.
   EXPECT_TRUE(Write(byte_stream_input.get(), 4000));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The task runner should have been hit, but the callback count
   // isn't changed until we actually run the callback.
   EXPECT_EQ(0, num_callbacks);
 
   // If we change the callback now, the new one should be run
   // (simulates race with post task).
   int num_alt_callbacks = 0;
   byte_stream_output->RegisterCallback(
       base::Bind(CountCallbacks, &num_alt_callbacks));
@@ skipping 25 matching lines @@
   size_t output_length;
   base::Closure intermediate_callback;
 
   // Setup state for test.
   int num_callbacks = 0;
   byte_stream_input->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
   EXPECT_TRUE(Write(byte_stream_input.get(), 2000));
   EXPECT_TRUE(Write(byte_stream_input.get(), 2001));
   EXPECT_FALSE(Write(byte_stream_input.get(), 6000));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Initial get should not trigger callback.
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Second get *should* trigger callback.
   EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   // Which should do the right thing when it's run.
   int num_alt_callbacks = 0;
   byte_stream_input->RegisterCallback(
       base::Bind(CountCallbacks, &num_alt_callbacks));
@@ skipping 33 matching lines @@
   EXPECT_EQ(1, num_callbacks);
 }
 
 TEST_F(ByteStreamTest, ByteStream_CloseWithoutAnyWrite) {
   std::unique_ptr<ByteStreamWriter> byte_stream_input;
   std::unique_ptr<ByteStreamReader> byte_stream_output;
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    3 * 1024, &byte_stream_input, &byte_stream_output);
 
   byte_stream_input->Close(0);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
   EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 }
 
 TEST_F(ByteStreamTest, ByteStream_FlushWithoutAnyWrite) {
   std::unique_ptr<ByteStreamWriter> byte_stream_input;
   std::unique_ptr<ByteStreamReader> byte_stream_output;
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    3 * 1024, &byte_stream_input, &byte_stream_output);
 
   byte_stream_input->Flush();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 
   byte_stream_input->Close(0);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 }
 
 TEST_F(ByteStreamTest, ByteStream_WriteOverflow) {
   std::unique_ptr<ByteStreamWriter> byte_stream_input;
   std::unique_ptr<ByteStreamReader> byte_stream_output;
   CreateByteStream(message_loop_.task_runner(), message_loop_.task_runner(),
                    std::numeric_limits<size_t>::max(), &byte_stream_input,
                    &byte_stream_output);
 
   EXPECT_TRUE(Write(byte_stream_input.get(), 1));
   // 1 + size_t max -> Overflow.
   scoped_refptr<net::IOBuffer> empty_io_buffer;
   EXPECT_FALSE(byte_stream_input->Write(empty_io_buffer,
                                         std::numeric_limits<size_t>::max()));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first write is below PostToPeer threshold. We shouldn't get anything
   // from the output.
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
   EXPECT_EQ(ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
 }
 
 }  // namespace content