Refactor net tests to use GMock matchers for checking net::Error results

net/spdy/spdy_session_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/spdy/spdy_session.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/base64.h"
@@ skipping 17 matching lines @@
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_session_test_util.h"
 #include "net/spdy/spdy_stream.h"
 #include "net/spdy/spdy_stream_test_util.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/cert_test_util.h"
+#include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 enum TestCase {
   // Test using the SPDY/3.1 protocol.
   kTestCaseSPDY31,
 
   // Test using the HTTP/2 protocol, without specifying a stream
   // dependency based on the RequestPriority.
@@ skipping 260 matching lines @@
   // |callback2| is never called.
   TestCompletionCallback callback2;
   ASSERT_EQ(ERR_IO_PENDING, request2->StartRequest(
                                 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_,
                                 MEDIUM, BoundNetLog(), callback2.callback()));
 
   callback1.SetRequestToDestroy(std::move(request2));
 
   session_->CloseSessionOnError(ERR_ABORTED, "Aborting session");
 
-  EXPECT_EQ(ERR_ABORTED, callback1.WaitForResult());
+  EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_ABORTED));
 }
 
 // A session receiving a GOAWAY frame with no active streams should close.
 TEST_P(SpdySessionTest, GoAwayWithNoActiveStreams) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   std::unique_ptr<SpdySerializedFrame> goaway(
       spdy_util_.ConstructSpdyGoAway(1));
   MockRead reads[] = {
     CreateMockRead(*goaway, 0),
@@ skipping 380 matching lines @@
 
   std::unique_ptr<SpdyHeaderBlock> headers(
       new SpdyHeaderBlock(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)));
   spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
 
   base::RunLoop().RunUntilIdle();
 
   // Stream and session closed gracefully.
   EXPECT_TRUE(delegate.StreamIsClosed());
-  EXPECT_EQ(OK, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsOk());
   EXPECT_EQ(kUploadData, delegate.TakeReceivedData());
   EXPECT_FALSE(session_);
 }
 
 // Try to create a stream after receiving a GOAWAY frame. It should
 // fail.
 TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   std::unique_ptr<SpdySerializedFrame> goaway(
@@ skipping 37 matching lines @@
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
   EXPECT_TRUE(session_->IsStreamActive(1));
 
   SpdyStreamRequest stream_request;
   int rv = stream_request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_,
                                        test_url_, MEDIUM, BoundNetLog(),
                                        CompletionCallback());
-  EXPECT_EQ(ERR_FAILED, rv);
+  EXPECT_THAT(rv, IsError(ERR_FAILED));
 
   EXPECT_TRUE(session_);
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(session_);
 }
 
 // Receiving a SYN_STREAM frame after a GOAWAY frame should result in
 // the stream being refused.
 TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
@@ skipping 157 matching lines @@
   session_->CheckPingStatus(before_ping_time);
 
   EXPECT_EQ(0, session_->pings_in_flight());
   EXPECT_GE(session_->next_ping_id(), 1U);
   EXPECT_FALSE(session_->check_ping_status_pending());
   EXPECT_GE(session_->last_activity_time(), before_ping_time);
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
   EXPECT_FALSE(session_);
 }
 
 TEST_P(SpdySessionTest, ServerPing) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   std::unique_ptr<SpdySerializedFrame> read_ping(
       spdy_util_.ConstructSpdyPing(2, false));
@@ skipping 173 matching lines @@
           new SpdyHeaderBlock(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl))),
       NO_MORE_DATA_TO_SEND);
   base::RunLoop().RunUntilIdle();
 
   // Active streams remain active.
   EXPECT_EQ(kLastStreamId, stream2->stream_id());
   EXPECT_EQ(2u, session_->num_active_streams());
 
   // Session is going away. Created and stalled streams were aborted.
   EXPECT_EQ(SpdySession::STATE_GOING_AWAY, session_->availability_state_);
-  EXPECT_EQ(ERR_ABORTED, delegate3.WaitForClose());
-  EXPECT_EQ(ERR_ABORTED, callback4.WaitForResult());
+  EXPECT_THAT(delegate3.WaitForClose(), IsError(ERR_ABORTED));
+  EXPECT_THAT(callback4.WaitForResult(), IsError(ERR_ABORTED));
   EXPECT_EQ(0u, session_->num_created_streams());
   EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM));
 
   // Read responses on remaining active streams.
   data.Resume();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(OK, delegate1.WaitForClose());
+  EXPECT_THAT(delegate1.WaitForClose(), IsOk());
   EXPECT_EQ(kUploadData, delegate1.TakeReceivedData());
-  EXPECT_EQ(OK, delegate2.WaitForClose());
+  EXPECT_THAT(delegate2.WaitForClose(), IsOk());
   EXPECT_EQ(kUploadData, delegate2.TakeReceivedData());
 
   // Session was destroyed.
   EXPECT_FALSE(session_);
 }
 
 // Regression test for https://crbug.com/481009.
 TEST_P(SpdySessionTest, MaxConcurrentStreamsZero) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
@@ skipping 60 matching lines @@
   // Receive SETTINGS frame that sets max_concurrent_streams to zero.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, session_->max_concurrent_streams_);
 
   // Start request.
   SpdyStreamRequest request;
   TestCompletionCallback callback;
   int rv =
       request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_,
                            MEDIUM, BoundNetLog(), callback.callback());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Stream is stalled.
   EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM));
   EXPECT_EQ(0u, session_->num_created_streams());
 
   // Receive SETTINGS frame that sets max_concurrent_streams to one.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, session_->max_concurrent_streams_);
 
   // Stream is created.
   EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM));
   EXPECT_EQ(1u, session_->num_created_streams());
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Send request.
   base::WeakPtr<SpdyStream> stream = request.ReleaseStream();
   test::StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
   std::unique_ptr<SpdyHeaderBlock> headers(
       new SpdyHeaderBlock(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)));
   stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(stream->HasUrlFromHeaders());
 
-  EXPECT_EQ(OK, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsOk());
   EXPECT_EQ("hello!", delegate.TakeReceivedData());
 
   // Session is destroyed.
   EXPECT_FALSE(session_);
 }
 
 // Verifies that an unstalled pending stream creation racing with a new stream
 // creation doesn't violate the maximum stream concurrency. Regression test for
 // crbug.com/373858.
 TEST_P(SpdySessionTest, UnstallRacesWithStreamCreation) {
@@ skipping 45 matching lines @@
   EXPECT_EQ(1u, session_->num_created_streams());
   EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM));
 
   // Cancel the third stream and run the message loop. Verify that the second
   // stream creation now completes.
   stream3->Cancel();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, session_->num_created_streams());
   EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM));
-  EXPECT_EQ(OK, callback2.WaitForResult());
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
 }
 
 TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.time_func = TheNearFuture;
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
@@ skipping 166 matching lines @@
 
   StreamReleaserCallback stream_releaser;
   SpdyStreamRequest request;
   ASSERT_EQ(ERR_IO_PENDING,
             request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_,
                                  MEDIUM, BoundNetLog(),
                                  stream_releaser.MakeCallback(&request)));
 
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(OK, stream_releaser.WaitForResult());
+  EXPECT_THAT(stream_releaser.WaitForResult(), IsOk());
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(session_);
 
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data.AllReadDataConsumed());
 }
 
 // Start with a persisted value for max concurrent streams. Receive a
@@ skipping 61 matching lines @@
   StreamReleaserCallback stream_releaser;
 
   SpdyStreamRequest request;
   ASSERT_EQ(ERR_IO_PENDING,
             request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_,
                                  MEDIUM, BoundNetLog(),
                                  stream_releaser.MakeCallback(&request)));
 
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(OK, stream_releaser.WaitForResult());
+  EXPECT_THAT(stream_releaser.WaitForResult(), IsOk());
 
   // Make sure that persisted data is cleared.
   EXPECT_TRUE(spdy_session_pool_->http_server_properties()
                   ->GetSpdySettings(test_server_)
                   .empty());
 
   // Make sure session's max_concurrent_streams is correct.
   EXPECT_EQ(kInitialMaxConcurrentStreams + 1,
             session_->max_concurrent_streams_);
 
@@ skipping 221 matching lines @@
     ASSERT_TRUE(entry.GetStringValue("debug_data", &debug_data));
     EXPECT_EQ("foo", debug_data);
   }
 
   // Check that we logged SPDY_SESSION_CLOSE correctly.
   int pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP2_SESSION_CLOSE, NetLog::PHASE_NONE);
   TestNetLogEntry entry = entries[pos];
   int error_code = 0;
   ASSERT_TRUE(entry.GetNetErrorCode(&error_code));
-  EXPECT_EQ(OK, error_code);
+  EXPECT_THAT(error_code, IsOk());
 }
 
 TEST_P(SpdySessionTest, NetLogOnSessionEOF) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
       MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
@@ skipping 15 matching lines @@
   EXPECT_LT(0u, entries.size());
 
   // Check that we logged SPDY_SESSION_CLOSE correctly.
   int pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP2_SESSION_CLOSE, NetLog::PHASE_NONE);
 
   if (pos < static_cast<int>(entries.size())) {
     TestNetLogEntry entry = entries[pos];
     int error_code = 0;
     ASSERT_TRUE(entry.GetNetErrorCode(&error_code));
-    EXPECT_EQ(ERR_CONNECTION_CLOSED, error_code);
+    EXPECT_THAT(error_code, IsError(ERR_CONNECTION_CLOSED));
   } else {
     ADD_FAILURE();
   }
 }
 
 TEST_P(SpdySessionTest, SynCompressionHistograms) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
@@ skipping 796 matching lines @@
 
   EXPECT_EQ(0u, session_->num_active_streams());
   EXPECT_EQ(kInitialMaxConcurrentStreams, session_->num_created_streams());
   EXPECT_EQ(2u, session_->pending_create_stream_queue_size(LOWEST));
 
   // Cancel the first stream; this will allow the second stream to be created.
   EXPECT_TRUE(spdy_stream1);
   spdy_stream1->Cancel();
   EXPECT_FALSE(spdy_stream1);
 
-  EXPECT_EQ(OK, callback2.WaitForResult());
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
   EXPECT_EQ(0u, session_->num_active_streams());
   EXPECT_EQ(kInitialMaxConcurrentStreams, session_->num_created_streams());
   EXPECT_EQ(1u, session_->pending_create_stream_queue_size(LOWEST));
 
   // Cancel the second stream; this will allow the third stream to be created.
   base::WeakPtr<SpdyStream> spdy_stream2 = request2.ReleaseStream();
   spdy_stream2->Cancel();
   EXPECT_FALSE(spdy_stream2);
 
-  EXPECT_EQ(OK, callback3.WaitForResult());
+  EXPECT_THAT(callback3.WaitForResult(), IsOk());
   EXPECT_EQ(0u, session_->num_active_streams());
   EXPECT_EQ(kInitialMaxConcurrentStreams, session_->num_created_streams());
   EXPECT_EQ(0u, session_->pending_create_stream_queue_size(LOWEST));
 
   // Cancel the third stream.
   base::WeakPtr<SpdyStream> spdy_stream3 = request3.ReleaseStream();
   spdy_stream3->Cancel();
   EXPECT_FALSE(spdy_stream3);
   EXPECT_EQ(0u, session_->num_active_streams());
   EXPECT_EQ(kInitialMaxConcurrentStreams - 1, session_->num_created_streams());
@@ skipping 530 matching lines @@
       TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   std::unique_ptr<ClientSocketHandle> connection2(new ClientSocketHandle);
   EXPECT_EQ(ERR_IO_PENDING,
             connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY,
                               ClientSocketPool::RespectLimits::ENABLED,
                               callback2.callback(), pool, BoundNetLog()));
   EXPECT_TRUE(pool->IsStalled());
 
   // The socket pool should close the connection asynchronously and establish a
   // new connection.
-  EXPECT_EQ(OK, callback2.WaitForResult());
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
   EXPECT_FALSE(pool->IsStalled());
   EXPECT_FALSE(session_);
 }
 
 // Tests the case of a non-SPDY request closing an idle SPDY session when no
 // pointers to the idle session are currently held, in the case the SPDY session
 // has an alias.
 TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
@@ skipping 54 matching lines @@
       TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   std::unique_ptr<ClientSocketHandle> connection3(new ClientSocketHandle);
   EXPECT_EQ(ERR_IO_PENDING,
             connection3->Init(host_port3.ToString(), params3, DEFAULT_PRIORITY,
                               ClientSocketPool::RespectLimits::ENABLED,
                               callback3.callback(), pool, BoundNetLog()));
   EXPECT_TRUE(pool->IsStalled());
 
   // The socket pool should close the connection asynchronously and establish a
   // new connection.
-  EXPECT_EQ(OK, callback3.WaitForResult());
+  EXPECT_THAT(callback3.WaitForResult(), IsOk());
   EXPECT_FALSE(pool->IsStalled());
   EXPECT_FALSE(session1);
   EXPECT_FALSE(session2);
 }
 
 // Tests that when a SPDY session becomes idle, it closes itself if there is
 // a lower layer pool stalled on the per-pool socket limit.
 TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
@@ skipping 71 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(pool->IsStalled());
   EXPECT_FALSE(callback2.have_result());
 
   // Cancelling the request should result in the session's socket being
   // closed, since the pool is stalled.
   ASSERT_TRUE(spdy_stream1.get());
   spdy_stream1->Cancel();
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(pool->IsStalled());
-  EXPECT_EQ(OK, callback2.WaitForResult());
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
 }
 
 // Verify that SpdySessionKey and therefore SpdySession is different when
 // privacy mode is enabled or disabled.
 TEST_P(SpdySessionTest, SpdySessionKeyPrivacyMode) {
   CreateNetworkSession();
 
   HostPortPair host_port_pair("www.example.org", 443);
   SpdySessionKey key_privacy_enabled(host_port_pair, ProxyServer::Direct(),
                                      PRIVACY_MODE_ENABLED);
@@ skipping 611 matching lines @@
   EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(initial_window_size, session_->session_recv_window_size_);
   EXPECT_EQ(kMsgDataSize, session_->session_unacked_recv_window_bytes_);
 
   stream->Close();
   EXPECT_FALSE(stream);
 
-  EXPECT_EQ(OK, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsOk());
 
   EXPECT_EQ(initial_window_size, session_->session_recv_window_size_);
   EXPECT_EQ(kMsgDataSize, session_->session_unacked_recv_window_bytes_);
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(session_);
 }
 
 // Send data back and forth but close the stream before its data frame
@@ skipping 54 matching lines @@
 
   EXPECT_EQ(initial_window_size - kMsgDataSize,
             session_->session_send_window_size_);
 
   // Closing the stream should increase the session's send window.
   stream->Close();
   EXPECT_FALSE(stream);
 
   EXPECT_EQ(initial_window_size, session_->session_send_window_size_);
 
-  EXPECT_EQ(OK, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsOk());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(session_);
 
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data.AllReadDataConsumed());
 }
 
 // Send data back and forth; the send and receive windows should
 // change appropriately.
@@ skipping 86 matching lines @@
 
   // Draining the delegate's read queue should increase the session's
   // receive window.
   EXPECT_EQ(initial_window_size, session_->session_send_window_size_);
   EXPECT_EQ(initial_window_size, session_->session_recv_window_size_);
   EXPECT_EQ(kMsgDataSize, session_->session_unacked_recv_window_bytes_);
 
   stream->Close();
   EXPECT_FALSE(stream);
 
-  EXPECT_EQ(OK, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsOk());
 
   EXPECT_EQ(initial_window_size, session_->session_send_window_size_);
   EXPECT_EQ(initial_window_size, session_->session_recv_window_size_);
   EXPECT_EQ(kMsgDataSize, session_->session_unacked_recv_window_bytes_);
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(session_);
 }
 
@@ skipping 47 matching lines @@
   stall_function.Run(stream.get());
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
   unstall_function.Run(stream.get(), kBodyDataSize);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
   EXPECT_FALSE(session_);
   EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Run the resume-after-unstall test with all possible stall and
 // unstall sequences.
@@ skipping 142 matching lines @@
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   // This should then unstall stream1.
   UnstallSessionSend(kBodyDataSize);
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
+  EXPECT_THAT(delegate1.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
+  EXPECT_THAT(delegate2.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
   EXPECT_TRUE(delegate1.send_headers_completed());
   EXPECT_EQ("200", delegate1.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
 
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
 
   EXPECT_FALSE(session_);
@@ skipping 148 matching lines @@
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   EXPECT_FALSE(session_->IsStreamActive(stream_id1));
   EXPECT_TRUE(session_->IsStreamActive(stream_id2));
   EXPECT_FALSE(session_->IsStreamActive(stream_id3));
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(stream2);
   EXPECT_FALSE(session_);
 
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
-  EXPECT_EQ(OK, delegate3.WaitForClose());
+  EXPECT_THAT(delegate1.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
+  EXPECT_THAT(delegate2.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
+  EXPECT_THAT(delegate3.WaitForClose(), IsOk());
 
   EXPECT_TRUE(delegate1.send_headers_completed());
   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
 
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
 
   EXPECT_TRUE(delegate3.send_headers_completed());
   EXPECT_EQ(std::string(), delegate3.TakeReceivedData());
@@ skipping 80 matching lines @@
 
   // Close the session (since we can't do it from within the delegate
   // method, since it's in the stream's loop).
   session_->CloseSessionOnError(ERR_CONNECTION_CLOSED, "Closing session");
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(session_);
 
   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
 
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
+  EXPECT_THAT(delegate1.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
+  EXPECT_THAT(delegate2.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
   EXPECT_TRUE(delegate1.send_headers_completed());
   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
 
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
 
   EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
@@ skipping 38 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Put session on the edge of overflowing it's recv window.
   session_->session_recv_window_size_ = 1;
 
   // Read response headers & body. Body overflows the session window, and a
   // goaway is written.
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(ERR_SPDY_FLOW_CONTROL_ERROR, delegate.WaitForClose());
+  EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_FLOW_CONTROL_ERROR));
   EXPECT_FALSE(session_);
 }
 
 TEST_P(SpdySessionTest, SplitHeaders) {
   GURL kStreamUrl("https://www.example.org/foo.dat");
   SpdyHeaderBlock headers;
   spdy_util_.AddUrlToHeaderBlock(kStreamUrl.spec(), &headers);
   headers["alpha"] = "beta";
 
   SpdyHeaderBlock request_headers;
@@ skipping 520 matching lines @@
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2u, session_->num_active_streams());
   EXPECT_EQ(0u, session_->num_created_streams());
   EXPECT_EQ(1u, session_->num_pushed_streams());
   EXPECT_EQ(0u, session_->num_active_pushed_streams());
 
   base::WeakPtr<SpdyStream> pushed_stream;
   int rv =
       session_->GetPushStream(GURL(kPushedUrl), &pushed_stream, BoundNetLog());
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
   ASSERT_TRUE(pushed_stream);
   test::StreamDelegateCloseOnHeaders delegate2(pushed_stream);
   pushed_stream->SetDelegate(&delegate2);
 
   // Receive headers for pushed stream. Delegate will cancel the stream, ensure
   // that all our counters are in consistent state.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, session_->num_active_streams());
   EXPECT_EQ(0u, session_->num_created_streams());
@@ skipping 538 matching lines @@
   ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(),
                                      "spdy_pooling.pem");
   ssl_info.is_issued_by_known_root = true;
   ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin));
 
   EXPECT_TRUE(SpdySession::CanPool(
       &tss, ssl_info, "www.example.org", "mail.example.org"));
 }
 
 }  // namespace net