Revert of Revert "[Mac] Reland r276808 Use a native MessagePump instead of a MessagePumpDefault"

jingle/glue/chrome_async_socket_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 "jingle/glue/chrome_async_socket.h"
 
 #include <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_pump_default.h"
 #include "jingle/glue/resolving_client_socket_factory.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/http/transport_security_state.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 112 matching lines @@
   scoped_ptr<net::CertVerifier> cert_verifier_;
   scoped_ptr<net::TransportSecurityState> transport_security_state_;
 };
 
 class ChromeAsyncSocketTest
     : public testing::Test,
       public sigslot::has_slots<> {
  protected:
   ChromeAsyncSocketTest()
       : ssl_socket_data_provider_(net::ASYNC, net::OK),
-        addr_("localhost", 35) {}
+        addr_("localhost", 35) {
+    // GTest death tests execute in a fork()ed but not exec()ed process.
+    // On OS X a CoreFoundation-backed message loop will exit with a
+    // __THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__
+    // when called.
+    // Explicitly create a MessagePumpDefault which can run in this enivronment.
+    scoped_ptr<base::MessagePump> pump(new base::MessagePumpDefault());
+    message_loop_.reset(new base::MessageLoop(pump.Pass()));
+  }
 
   virtual ~ChromeAsyncSocketTest() {}
 
   virtual void SetUp() {
     scoped_ptr<net::MockClientSocketFactory> mock_client_socket_factory(
         new net::MockClientSocketFactory());
     mock_client_socket_factory->AddSocketDataProvider(
         &async_socket_data_provider_);
     mock_client_socket_factory->AddSSLSocketDataProvider(
         &ssl_socket_data_provider_);
@@ skipping 18 matching lines @@
     chrome_async_socket_->SignalClosed.connect(
         this, &ChromeAsyncSocketTest::OnClose);
     chrome_async_socket_->SignalRead.connect(
         this, &ChromeAsyncSocketTest::OnRead);
     chrome_async_socket_->SignalError.connect(
         this, &ChromeAsyncSocketTest::OnError);
   }
 
   virtual void TearDown() {
     // Run any tasks that we forgot to pump.
-    message_loop_.RunUntilIdle();
+    message_loop_->RunUntilIdle();
     ExpectClosed();
     ExpectNoSignal();
     chrome_async_socket_.reset();
   }
 
   enum Signal {
     SIGNAL_CONNECT,
     SIGNAL_SSL_CONNECT,
     SIGNAL_CLOSE,
     SIGNAL_READ,
@@ skipping 139 matching lines @@
 
   // Open/close utility functions.
 
   void DoOpenClosed() {
     ExpectClosed();
     async_socket_data_provider_.set_connect_data(
         net::MockConnect(net::SYNCHRONOUS, net::OK));
     EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
     ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
 
-    message_loop_.RunUntilIdle();
+    message_loop_->RunUntilIdle();
     // We may not necessarily be open; may have been other events
     // queued up.
     ExpectSignalSocketState(
         SignalSocketState::NoError(
             SIGNAL_CONNECT, ChromeAsyncSocket::STATE_OPEN));
   }
 
   void DoCloseOpened(SignalSocketState expected_signal_socket_state) {
     // We may be in an error state, so just compare state().
     EXPECT_EQ(ChromeAsyncSocket::STATE_OPEN, chrome_async_socket_->state());
     EXPECT_TRUE(chrome_async_socket_->Close());
     ExpectSignalSocketState(expected_signal_socket_state);
     ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED);
   }
 
   void DoCloseOpenedNoError() {
     DoCloseOpened(
         SignalSocketState::NoError(
             SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
   }
 
   void DoSSLOpenClosed() {
     const char kDummyData[] = "dummy_data";
     async_socket_data_provider_.AddRead(net::MockRead(kDummyData));
     DoOpenClosed();
     ExpectReadSignal();
     EXPECT_EQ(kDummyData, DrainRead(1));
 
     EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
-    message_loop_.RunUntilIdle();
+    message_loop_->RunUntilIdle();
     ExpectSSLConnectSignal();
     ExpectNoSignal();
     ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
   }
 
   void DoSSLCloseOpened(SignalSocketState expected_signal_socket_state) {
     // We may be in an error state, so just compare state().
     EXPECT_EQ(ChromeAsyncSocket::STATE_TLS_OPEN,
               chrome_async_socket_->state());
     EXPECT_TRUE(chrome_async_socket_->Close());
@@ skipping 22 matching lines @@
       }
       if (len_read == 0U) {
         break;
       }
       read.append(buf.get(), len_read);
     }
     return read;
   }
 
   // ChromeAsyncSocket expects a message loop.
-  base::MessageLoop message_loop_;
+  scoped_ptr<base::MessageLoop> message_loop_;
 
   AsyncSocketDataProvider async_socket_data_provider_;
   net::SSLSocketDataProvider ssl_socket_data_provider_;
 
   scoped_ptr<ChromeAsyncSocket> chrome_async_socket_;
   std::deque<SignalSocketState> signal_socket_states_;
   const talk_base::SocketAddress addr_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeAsyncSocketTest);
@@ skipping 74 matching lines @@
 
 TEST_F(ChromeAsyncSocketTest, ImmediateConnectCloseBeforeRead) {
   DoOpenClosed();
 
   EXPECT_TRUE(chrome_async_socket_->Close());
   ExpectClosed();
   ExpectSignalSocketState(
       SignalSocketState::NoError(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 }
 
 TEST_F(ChromeAsyncSocketTest, HangingConnect) {
   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
   ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
   ExpectNoSignal();
 
   EXPECT_TRUE(chrome_async_socket_->Close());
   ExpectClosed();
   ExpectSignalSocketState(
       SignalSocketState::NoError(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 }
 
 TEST_F(ChromeAsyncSocketTest, PendingConnect) {
   async_socket_data_provider_.set_connect_data(
       net::MockConnect(net::ASYNC, net::OK));
   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
   ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
   ExpectNoSignal();
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   ExpectNonErrorState(ChromeAsyncSocket::STATE_OPEN);
   ExpectSignalSocketState(
       SignalSocketState::NoError(
           SIGNAL_CONNECT, ChromeAsyncSocket::STATE_OPEN));
   ExpectNoSignal();
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   DoCloseOpenedNoError();
 }
 
 // After this no need to test successful pending connect so
 // thoroughly.
 
 TEST_F(ChromeAsyncSocketTest, PendingConnectCloseBeforeRead) {
   async_socket_data_provider_.set_connect_data(
       net::MockConnect(net::ASYNC, net::OK));
   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   ExpectSignalSocketState(
       SignalSocketState::NoError(
           SIGNAL_CONNECT, ChromeAsyncSocket::STATE_OPEN));
 
   DoCloseOpenedNoError();
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 }
 
 TEST_F(ChromeAsyncSocketTest, PendingConnectError) {
   async_socket_data_provider_.set_connect_data(
       net::MockConnect(net::ASYNC, net::ERR_TIMED_OUT));
   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectSignalSocketState(
       SignalSocketState(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 }
 
 // After this we can assume Connect() and Close() work as expected.
 
 TEST_F(ChromeAsyncSocketTest, EmptyRead) {
@@ skipping 41 matching lines @@
 
 TEST_F(ChromeAsyncSocketTest, Read) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
 
   ExpectReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   DoCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, ReadTwice) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
 
   ExpectReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   const char kReadData2[] = "mydatatoread2";
   async_socket_data_provider_.AddRead(net::MockRead(kReadData2));
 
   ExpectReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData2, DrainRead(1));
 
   DoCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, ReadError) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
 
   ExpectReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   async_socket_data_provider_.AddRead(
       net::MockRead(net::SYNCHRONOUS, net::ERR_TIMED_OUT));
 
   ExpectSignalSocketState(
       SignalSocketState(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 }
 
@@ skipping 13 matching lines @@
 
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 
   ExpectSignalSocketState(
       SignalSocketState::NoError(
           SIGNAL_READ, ChromeAsyncSocket::STATE_OPEN));
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   DoCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, PendingEmptyRead) {
   DoOpenClosed();
 
   ExpectNoSignal();
 
   async_socket_data_provider_.AddRead(net::MockRead(""));
@@ skipping 35 matching lines @@
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::SYNCHRONOUS,
                      kWriteData + 8, arraysize(kWriteData) - 8));
   DoOpenClosed();
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectNoSignal();
 
   DoCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, AsyncWrite) {
   DoOpenClosed();
 
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData + 8, arraysize(kWriteData) - 8));
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectNoSignal();
 
   DoCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, AsyncWriteError) {
   DoOpenClosed();
 
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, net::ERR_TIMED_OUT));
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectSignalSocketState(
       SignalSocketState(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 }
 
 TEST_F(ChromeAsyncSocketTest, LargeWrite) {
   EXPECT_DEBUG_DEATH({
     DoOpenClosed();
@@ skipping 47 matching lines @@
                                  ChromeAsyncSocket::STATE_CLOSED));
   ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED);
 }
 
 TEST_F(ChromeAsyncSocketTest, ImmediateSSLConnect) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
   ExpectReadSignal();
 
   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   ExpectSSLConnectSignal();
   ExpectNoSignal();
   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 
   DoSSLCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, DoubleSSLConnect) {
   EXPECT_DEBUG_DEATH({
     async_socket_data_provider_.AddRead(net::MockRead(kReadData));
     DoOpenClosed();
     ExpectReadSignal();
 
     EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
-    message_loop_.RunUntilIdle();
+    message_loop_->RunUntilIdle();
     ExpectSSLConnectSignal();
     ExpectNoSignal();
     ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 
     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
 
     DoSSLCloseOpened(
         SignalSocketState(SIGNAL_CLOSE,
                           ChromeAsyncSocket::STATE_CLOSED,
                           ChromeAsyncSocket::ERROR_WRONGSTATE,
                           net::OK));
   }, "wrong state");
 }
 
 TEST_F(ChromeAsyncSocketTest, FailedSSLConnect) {
   ssl_socket_data_provider_.connect =
       net::MockConnect(net::ASYNC, net::ERR_CERT_COMMON_NAME_INVALID),
 
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
   ExpectReadSignal();
 
   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   ExpectSignalSocketState(
       SignalSocketState(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
           ChromeAsyncSocket::ERROR_WINSOCK,
           net::ERR_CERT_COMMON_NAME_INVALID));
 
   EXPECT_TRUE(chrome_async_socket_->Close());
   ExpectClosed();
 }
 
 TEST_F(ChromeAsyncSocketTest, ReadDuringSSLConnecting) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
   ExpectReadSignal();
   EXPECT_EQ(kReadData, DrainRead(1));
 
   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
   ExpectNoSignal();
 
   // Shouldn't do anything.
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 
   char buf[4096];
   size_t len_read = 10000U;
   EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
   EXPECT_EQ(0U, len_read);
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   ExpectSSLConnectSignal();
   ExpectSSLReadSignal();
   ExpectNoSignal();
   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 
   len_read = 10000U;
   EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
   EXPECT_EQ(kReadData, std::string(buf, len_read));
 
   DoSSLCloseOpenedNoError();
@@ skipping 10 matching lines @@
 
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData, 3));
 
   // Shouldn't do anything.
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 
   // TODO(akalin): Figure out how to test that the write happens
   // *after* the SSL connect.
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   ExpectSSLConnectSignal();
   ExpectNoSignal();
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   DoSSLCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPendingRead) {
   EXPECT_DEBUG_DEATH({
     DoOpenClosed();
 
     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
 
     DoCloseOpened(
         SignalSocketState(SIGNAL_CLOSE,
                           ChromeAsyncSocket::STATE_CLOSED,
                           ChromeAsyncSocket::ERROR_WRONGSTATE,
                           net::OK));
   }, "wrong state");
 }
 
 TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPostedWrite) {
   EXPECT_DEBUG_DEATH({
     DoOpenClosed();
 
     async_socket_data_provider_.AddWrite(
         net::MockWrite(net::ASYNC, kWriteData, 3));
     EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 
     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
 
-    message_loop_.RunUntilIdle();
+    message_loop_->RunUntilIdle();
 
     DoCloseOpened(
         SignalSocketState(SIGNAL_CLOSE,
                           ChromeAsyncSocket::STATE_CLOSED,
                           ChromeAsyncSocket::ERROR_WRONGSTATE,
                           net::OK));
   }, "wrong state");
 }
 
 // After this we can assume SSL connect works as expected.
 
 TEST_F(ChromeAsyncSocketTest, SSLRead) {
   DoSSLOpenClosed();
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectSSLReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   DoSSLCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, SSLSyncWrite) {
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::SYNCHRONOUS,
                      kWriteData + 8, arraysize(kWriteData) - 8));
   DoSSLOpenClosed();
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, SSLAsyncWrite) {
   DoSSLOpenClosed();
 
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
       net::MockWrite(net::ASYNC, kWriteData + 8, arraysize(kWriteData) - 8));
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
-  message_loop_.RunUntilIdle();
+  message_loop_->RunUntilIdle();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 }  // namespace
 
 }  // namespace jingle_glue