Cleanup the unittest helpers in load_log_unittest.h.

Consolidates all the callers to using the testing::AssertionResult() flavor, and renames them to have "Event" in the name. This rename is in anticipation of adding testers for other entry types.

BUG=NONE
TEST=existing

Review URL: http://codereview.chromium.org/551135

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@37501 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 112 insertions, 133 deletions

diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index 495a7f2..d4c510f8 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -484,12 +484,13 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
   EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult());
 
   EXPECT_EQ(3u, log->entries().size());
-  ExpectLogContains(log, 0, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
-                    LoadLog::PHASE_NONE);
-  ExpectLogContains(log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_END);
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 0, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEvent(
+      *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
+      LoadLog::PHASE_NONE));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
@@ -505,12 +506,12 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
   handle.Reset();
 
   EXPECT_EQ(4u, log->entries().size());
-  ExpectLogContains(log, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log, 3, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_END);
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(*log, 3, LoadLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
@@ -524,12 +525,12 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
                        pool_.get(), log));
 
   EXPECT_EQ(4u, log->entries().size());
-  ExpectLogContains(log, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log, 3, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_END);
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(*log, 3, LoadLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
@@ -1125,19 +1126,17 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
   req.handle()->Reset();
 
   EXPECT_EQ(6u, log->entries().size());
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN));
-  EXPECT_TRUE(LogContains(
-      *log, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-      LoadLog::PHASE_BEGIN));
-  EXPECT_TRUE(LogContains(
-      *log, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE, LoadLog::PHASE_END));
-  EXPECT_TRUE(LogContains(
-      *log, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB, LoadLog::PHASE_BEGIN));
-  EXPECT_TRUE(LogContains(
-      *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB, LoadLog::PHASE_END));
-  EXPECT_TRUE(LogContains(
-      *log, 5, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 5, LoadLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
@@ -1154,16 +1153,16 @@ TEST_F(ClientSocketPoolBaseTest,
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 
   EXPECT_EQ(6u, log->entries().size());
-  ExpectLogContains(log, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log, 5, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_END);
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(*log, 5, LoadLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
@@ -1185,35 +1184,36 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
   req.handle()->Reset();
 
   EXPECT_EQ(5u, log1->entries().size());
-  ExpectLogContains(log1, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log1, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log1, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log1, 3, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
-  ExpectLogContains(log1, 4, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_END);
+  EXPECT_TRUE(LogContainsBeginEvent(*log1, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log1, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log1, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsEvent(
+      *log1, 3, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE));
+  EXPECT_TRUE(LogContainsEndEvent(*log1, 4, LoadLog::TYPE_SOCKET_POOL));
 
   // At this point, request 2 is just waiting for the connect job to finish.
   EXPECT_EQ(2u, log2->entries().size());
-  ExpectLogContains(log2, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log2, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_BEGIN);
+  EXPECT_TRUE(LogContainsBeginEvent(*log2, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log2, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
 
   EXPECT_EQ(OK, req2.WaitForResult());
   req2.handle()->Reset();
 
   // Now request 2 has actually finished.
   EXPECT_EQ(6u, log2->entries().size());
-  ExpectLogContains(log2, 0, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log2, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log1, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log2, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_BEGIN);
-  ExpectLogContains(log2, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB,
-                    LoadLog::PHASE_END);
-  ExpectLogContains(log2, 5, LoadLog::TYPE_SOCKET_POOL, LoadLog::PHASE_END);
+  EXPECT_TRUE(LogContainsBeginEvent(*log2, 0, LoadLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log2, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log1, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log2, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(
+      *log2, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+  EXPECT_TRUE(LogContainsEndEvent(*log2, 5, LoadLog::TYPE_SOCKET_POOL));
 
 }
 
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index ac7ff5a..b4eb2cf 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -125,15 +125,13 @@ TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(user_sock_->IsConnected());
-  EXPECT_TRUE(
-      LogContains(*log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS5_CONNECT));
 
   rv = callback_.WaitForResult();
 
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS5_CONNECT));
 
   scoped_refptr<IOBuffer> buffer = new IOBuffer(payload_write.size());
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
@@ -238,13 +236,11 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContains(
-        *log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
+    EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContains(
-        *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
+    EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS5_CONNECT));
   }
 
   // Test for partial greet response read
@@ -262,13 +258,11 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContains(
-        *log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
+    EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContains(
-        *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
+    EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS5_CONNECT));
   }
 
   // Test for partial handshake request write.
@@ -287,13 +281,11 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContains(
-        *log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
+    EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContains(
-        *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
+    EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS5_CONNECT));
   }
 
   // Test for partial handshake response read
@@ -306,20 +298,19 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
     MockRead data_reads[] = {
         MockRead(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
         MockRead(true, kSOCKS5OkResponse, kSplitPoint),
-        MockRead(true, kSOCKS5OkResponse + kSplitPoint, arraysize(kSOCKS5OkResponse) - kSplitPoint)
+        MockRead(true, kSOCKS5OkResponse + kSplitPoint,
+                 arraysize(kSOCKS5OkResponse) - kSplitPoint)
     };
 
     user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80));
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContains(
-        *log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
+    EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContains(
-        *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
+    EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS5_CONNECT));
   }
 }
 
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index 6cf450e..2b4bf58 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -139,15 +139,14 @@ TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_TRUE(
-      LogContains(*log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+      LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT));
   EXPECT_FALSE(user_sock_->IsConnected());
   rv = callback_.WaitForResult();
 
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   EXPECT_EQ(SOCKSClientSocket::kSOCKS4, user_sock_->socks_version_);
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
 
   scoped_refptr<IOBuffer> buffer = new IOBuffer(payload_write.size());
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
@@ -201,14 +200,12 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
 
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContains(
-        *log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+    EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(tests[i].fail_code, rv);
     EXPECT_FALSE(user_sock_->IsConnected());
     EXPECT_TRUE(tcp_sock_->IsConnected());
-    EXPECT_TRUE(LogContains(
-        *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+    EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
   }
 }
 
@@ -230,13 +227,12 @@ TEST_F(SOCKSClientSocketTest, PartialServerReads) {
 
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      *log, 0, LoadLog::TYPE_SOCKS_CONNECT));
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tests scenario when the client sends the handshake request in
@@ -261,13 +257,11 @@ TEST_F(SOCKSClientSocketTest, PartialClientWrites) {
 
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT));
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tests the case when the server sends a smaller sized handshake data
@@ -286,13 +280,11 @@ TEST_F(SOCKSClientSocketTest, FailedSocketRead) {
 
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT));
   rv = callback_.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
   EXPECT_FALSE(user_sock_->IsConnected());
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tries to connect to an unknown DNS and on failure should revert to SOCKS4A.
@@ -316,14 +308,12 @@ TEST_F(SOCKSClientSocketTest, SOCKS4AFailedDNS) {
 
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT));
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_);
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tries to connect to a domain that resolves to IPv6.
@@ -348,14 +338,12 @@ TEST_F(SOCKSClientSocketTest, SOCKS4AIfDomainInIPv6) {
 
   int rv = user_sock_->Connect(&callback_, log);
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT));
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_);
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS_CONNECT, LoadLog::PHASE_END));
+  EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT));
 }
 
 // Calls Disconnect() while a host resolve is in progress. The outstanding host
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index 2fca322..a3556dc 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -82,21 +82,21 @@ TEST_F(SSLClientSocketTest, Connect) {
 
   scoped_refptr<net::LoadLog> log(new net::LoadLog(net::LoadLog::kUnbounded));
   rv = sock->Connect(&callback, log);
-  EXPECT_TRUE(net::LogContains(
-      *log, 0, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(net::LogContainsBeginEvent(
+      *log, 0, net::LoadLog::TYPE_SSL_CONNECT));
   if (rv != net::OK) {
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
     EXPECT_FALSE(sock->IsConnected());
-    EXPECT_FALSE(net::LogContains(
-        *log, -1, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_END));
+    EXPECT_FALSE(net::LogContainsEndEvent(
+        *log, -1, net::LoadLog::TYPE_SSL_CONNECT));
 
     rv = callback.WaitForResult();
     EXPECT_EQ(net::OK, rv);
   }
 
   EXPECT_TRUE(sock->IsConnected());
-  EXPECT_TRUE(net::LogContains(
-      *log, -1, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_END));
+  EXPECT_TRUE(net::LogContainsEndEvent(
+      *log, -1, net::LoadLog::TYPE_SSL_CONNECT));
 
   sock->Disconnect();
   EXPECT_FALSE(sock->IsConnected());
@@ -126,13 +126,13 @@ TEST_F(SSLClientSocketTest, ConnectExpired) {
 
   scoped_refptr<net::LoadLog> log(new net::LoadLog(net::LoadLog::kUnbounded));
   rv = sock->Connect(&callback, log);
-  EXPECT_TRUE(net::LogContains(
-      *log, 0, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(net::LogContainsBeginEvent(
+      *log, 0, net::LoadLog::TYPE_SSL_CONNECT));
   if (rv != net::OK) {
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
     EXPECT_FALSE(sock->IsConnected());
-    EXPECT_FALSE(net::LogContains(
-        *log, -1, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_END));
+    EXPECT_FALSE(net::LogContainsEndEvent(
+        *log, -1, net::LoadLog::TYPE_SSL_CONNECT));
 
     rv = callback.WaitForResult();
     EXPECT_EQ(net::ERR_CERT_DATE_INVALID, rv);
@@ -142,8 +142,8 @@ TEST_F(SSLClientSocketTest, ConnectExpired) {
   // the socket when it encounters an error, whereas other implementations
   // leave it connected.
 
-  EXPECT_TRUE(net::LogContains(
-      *log, -1, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_END));
+  EXPECT_TRUE(net::LogContainsEndEvent(
+      *log, -1, net::LoadLog::TYPE_SSL_CONNECT));
 }
 
 TEST_F(SSLClientSocketTest, ConnectMismatched) {
@@ -171,13 +171,13 @@ TEST_F(SSLClientSocketTest, ConnectMismatched) {
 
   scoped_refptr<net::LoadLog> log(new net::LoadLog(net::LoadLog::kUnbounded));
   rv = sock->Connect(&callback, log);
-  EXPECT_TRUE(net::LogContains(
-      *log, 0, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(net::LogContainsBeginEvent(
+      *log, 0, net::LoadLog::TYPE_SSL_CONNECT));
   if (rv != net::ERR_CERT_COMMON_NAME_INVALID) {
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
     EXPECT_FALSE(sock->IsConnected());
-    EXPECT_FALSE(net::LogContains(
-        *log, -1, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_END));
+    EXPECT_FALSE(net::LogContainsEndEvent(
+        *log, -1, net::LoadLog::TYPE_SSL_CONNECT));
 
     rv = callback.WaitForResult();
     EXPECT_EQ(net::ERR_CERT_COMMON_NAME_INVALID, rv);
@@ -187,8 +187,8 @@ TEST_F(SSLClientSocketTest, ConnectMismatched) {
   // the socket when it encounters an error, whereas other implementations
   // leave it connected.
 
-  EXPECT_TRUE(net::LogContains(
-      *log, -1, net::LoadLog::TYPE_SSL_CONNECT, net::LoadLog::PHASE_END));
+  EXPECT_TRUE(net::LogContainsEndEvent(
+      *log, -1, net::LoadLog::TYPE_SSL_CONNECT));
 }
 
 // TODO(wtc): Add unit tests for IsConnectedAndIdle:
diff --git a/net/socket/tcp_client_socket_unittest.cc b/net/socket/tcp_client_socket_unittest.cc
index d797e05..eebdc9f 100644
--- a/net/socket/tcp_client_socket_unittest.cc
+++ b/net/socket/tcp_client_socket_unittest.cc
@@ -101,20 +101,20 @@ TEST_F(TCPClientSocketTest, Connect) {
 
   scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
   int rv = sock_->Connect(&callback, log);
-  EXPECT_TRUE(net::LogContains(
-      *log, 0, net::LoadLog::TYPE_TCP_CONNECT, net::LoadLog::PHASE_BEGIN));
+  EXPECT_TRUE(net::LogContainsBeginEvent(
+      *log, 0, net::LoadLog::TYPE_TCP_CONNECT));
   if (rv != OK) {
     ASSERT_EQ(rv, ERR_IO_PENDING);
-    EXPECT_FALSE(net::LogContains(
-        *log, -1, net::LoadLog::TYPE_TCP_CONNECT, net::LoadLog::PHASE_END));
+    EXPECT_FALSE(net::LogContainsEndEvent(
+        *log, -1, net::LoadLog::TYPE_TCP_CONNECT));
 
     rv = callback.WaitForResult();
     EXPECT_EQ(rv, OK);
   }
 
   EXPECT_TRUE(sock_->IsConnected());
-  EXPECT_TRUE(net::LogContains(
-      *log, -1, net::LoadLog::TYPE_TCP_CONNECT, net::LoadLog::PHASE_END));
+  EXPECT_TRUE(net::LogContainsEndEvent(
+      *log, -1, net::LoadLog::TYPE_TCP_CONNECT));
 
   sock_->Disconnect();
   EXPECT_FALSE(sock_->IsConnected());