Remove MessageLoop::current()->RunUntilIdle() in net.

net/socket/sequenced_socket_data_unittest.cc

 // Copyright 2015 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 <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
@@ skipping 472 matching lines @@
   Initialize(reads, arraysize(reads), nullptr, 0);
 
   read_buf_ = new IOBuffer(kLen1);
   ASSERT_EQ(
       ERR_IO_PENDING,
       sock_->Read(
           read_buf_.get(), kLen1,
           base::Bind(&SequencedSocketDataTest::ReentrantReadCallback,
                      base::Unretained(this), kMsg1, kLen1, kLen2, kLen2)));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   AssertReadBufferEquals(kMsg2, kLen2);
 }
 
 TEST_F(SequencedSocketDataTest, ManyReentrantReads) {
   MockRead reads[] = {
       MockRead(ASYNC, kMsg1, kLen1, 0),
       MockRead(ASYNC, kMsg2, kLen2, 1),
       MockRead(ASYNC, kMsg3, kLen3, 2),
       MockRead(ASYNC, kMsg4, kLen4, 3),
   };
@@ skipping 104 matching lines @@
 
   Initialize(reads, arraysize(reads), nullptr, 0);
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(1));
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(read_buf.get(), 1, read_callback_.callback()));
   ASSERT_FALSE(read_callback_.have_result());
 
   // Even though the read is scheduled to complete at sequence number 0,
   // verify that the read callback in never called.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(read_callback_.have_result());
 }
 
 // ----------- Write
 
 TEST_F(SequencedSocketDataTest, SingleSyncWriteTooEarly) {
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1),
   };
 
@@ skipping 159 matching lines @@
 
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
   memcpy(write_buf->data(), kMsg1, kLen1);
   ASSERT_EQ(
       ERR_IO_PENDING,
       sock_->Write(
           write_buf.get(), kLen1,
           base::Bind(&SequencedSocketDataTest::ReentrantWriteCallback,
                      base::Unretained(this), kLen1, kMsg2, kLen2, kLen2)));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SequencedSocketDataTest, AsyncWriteFromCompletionCallback) {
   MockWrite writes[] = {
       MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg2, kLen2, 1),
   };
 
   Initialize(nullptr, 0, writes, arraysize(writes));
 
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
@@ skipping 264 matching lines @@
   ReentrantHelper helper(sock_);
   helper.SetExpectedWrite(kLen1);
   helper.SetInvokeRead(helper2.read_buf(), kLen2, ERR_IO_PENDING,
                        helper2.callback());
 
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
   memcpy(write_buf->data(), kMsg1, kLen1);
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Write(write_buf.get(), kLen1, helper.callback()));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   AssertReadBufferEquals(kMsg4, kLen4);
 }
 
 TEST_F(SequencedSocketDataTest, MixedReentrantOperationsThenSynchronousWrite) {
   MockWrite writes[] = {
       MockWrite(ASYNC, kMsg2, kLen2, 1),
       MockWrite(SYNCHRONOUS, kMsg4, kLen4, 3),
   };
 
   MockRead reads[] = {
@@ skipping 13 matching lines @@
   helper2.SetInvokeRead(helper3.read_buf(), kLen3, ERR_IO_PENDING,
                         helper3.callback());
 
   ReentrantHelper helper(sock_);
   helper.SetExpectedRead(kMsg1, kLen1);
   helper.SetInvokeWrite(kMsg2, kLen2, ERR_IO_PENDING, helper2.callback());
 
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(helper.read_buf().get(), kLen1, helper.callback()));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Test the basic case where a read is paused.
 TEST_F(SequencedSocketDataTest, PauseAndResume_PauseRead) {
   MockRead reads[] = {
       MockRead(ASYNC, ERR_IO_PENDING, 0), MockRead(ASYNC, kMsg1, kLen1, 1),
   };
 
   Initialize(reads, arraysize(reads), nullptr, 0);
 
   AssertReadReturns(kLen1, ERR_IO_PENDING);
   ASSERT_FALSE(read_callback_.have_result());
 
   RunUntilPaused();
   ASSERT_TRUE(IsPaused());
 
   // Spinning the message loop should do nothing.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(read_callback_.have_result());
   ASSERT_TRUE(IsPaused());
 
   Resume();
   ASSERT_FALSE(IsPaused());
   ASSERT_TRUE(read_callback_.have_result());
   ASSERT_EQ(kLen1, read_callback_.WaitForResult());
   AssertReadBufferEquals(kMsg1, kLen1);
 }
 
 // Test the case where a read that will be paused is started before write that
 // completes before the pause.
 TEST_F(SequencedSocketDataTest, PauseAndResume_WritePauseRead) {
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
   };
 
   MockRead reads[] = {
       MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, kMsg2, kLen2, 2),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertReadReturns(kLen2, ERR_IO_PENDING);
   ASSERT_FALSE(read_callback_.have_result());
 
   // Nothing should happen until the write starts.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(read_callback_.have_result());
   ASSERT_FALSE(IsPaused());
 
   AssertSyncWriteEquals(kMsg1, kLen1);
 
   RunUntilPaused();
   ASSERT_FALSE(read_callback_.have_result());
   ASSERT_TRUE(IsPaused());
 
   // Spinning the message loop should do nothing.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(read_callback_.have_result());
   ASSERT_TRUE(IsPaused());
 
   Resume();
   ASSERT_FALSE(IsPaused());
   ASSERT_TRUE(read_callback_.have_result());
   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
   AssertReadBufferEquals(kMsg2, kLen2);
 }
 
 // Test the basic case where a write is paused.
 TEST_F(SequencedSocketDataTest, PauseAndResume_PauseWrite) {
   MockWrite writes[] = {
       MockWrite(ASYNC, ERR_IO_PENDING, 0), MockWrite(ASYNC, kMsg1, kLen1, 1),
   };
 
   Initialize(nullptr, 0, writes, arraysize(writes));
 
   AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
   ASSERT_FALSE(write_callback_.have_result());
 
   RunUntilPaused();
   ASSERT_TRUE(IsPaused());
 
   // Spinning the message loop should do nothing.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(write_callback_.have_result());
   ASSERT_TRUE(IsPaused());
 
   Resume();
   ASSERT_FALSE(IsPaused());
   ASSERT_TRUE(write_callback_.have_result());
   ASSERT_EQ(kLen1, write_callback_.WaitForResult());
 }
 
 // Test the case where a write that will be paused is started before read that
 // completes before the pause.
 TEST_F(SequencedSocketDataTest, PauseAndResume_ReadPauseWrite) {
   MockWrite writes[] = {
       MockWrite(ASYNC, ERR_IO_PENDING, 1), MockWrite(ASYNC, kMsg2, kLen2, 2),
   };
 
   MockRead reads[] = {
       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
   ASSERT_FALSE(write_callback_.have_result());
 
   // Nothing should happen until the write starts.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(write_callback_.have_result());
   ASSERT_FALSE(IsPaused());
 
   AssertSyncReadEquals(kMsg1, kLen1);
 
   RunUntilPaused();
   ASSERT_FALSE(write_callback_.have_result());
   ASSERT_TRUE(IsPaused());
 
   // Spinning the message loop should do nothing.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(write_callback_.have_result());
   ASSERT_TRUE(IsPaused());
 
   Resume();
   ASSERT_FALSE(IsPaused());
   ASSERT_TRUE(write_callback_.have_result());
   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace net