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

net/spdy/spdy_network_transaction_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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 27 matching lines @@
 #include "net/socket/next_proto.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/test/cert_test_util.h"
+#include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 namespace {
 
 using testing::Each;
 using testing::Eq;
 
 const int32_t kBufferSize = SpdyHttpStream::kRequestBodyBufferSize;
@@ skipping 466 matching lines @@
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunPreTestSetup();
     helper.AddData(data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
     TestCompletionCallback callback;
     int rv = trans->Start(
         &CreateGetRequest(), callback.callback(), BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     rv = callback.WaitForResult();
 
     // Request the pushed path.
     std::unique_ptr<HttpNetworkTransaction> trans2(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
     rv = trans2->Start(
         &CreateGetPushRequest(), callback.callback(), BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     base::RunLoop().RunUntilIdle();
 
     // The data for the pushed path may be coming in more than 1 frame. Compile
     // the results into a single string.
 
     // Read the server push body.
     std::string result2;
     ReadResult(trans2.get(), &result2);
     // Read the response body.
     std::string result;
@@ skipping 36 matching lines @@
                                        GURL url,
                                        int result) {
     std::unique_ptr<HttpNetworkTransaction> trans(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
     TestCompletionCallback callback;
     HttpRequestInfo request;
     request.method = "GET";
     request.url = url;
     request.load_flags = 0;
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     callback.WaitForResult();
   }
 
   ChunkedUploadDataStream* upload_chunked_data_stream() const {
     return upload_chunked_data_stream_.get();
   }
 
   std::string GetDefaultUrlWithPath(const char* path) {
     return std::string(kDefaultUrl) + path;
   }
@@ skipping 53 matching lines @@
       CreateMockRead(*resp, 1),
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
   for (RequestPriority p = MINIMUM_PRIORITY; p <= MAXIMUM_PRIORITY;
        p = RequestPriority(p + 1)) {
     SpdyTestUtil spdy_test_util(GetParam().protocol,
                                 GetParam().priority_to_dependency);
 
@@ skipping 39 matching lines @@
     };
 
     SequencedSocketData data(reads, arraysize(reads), writes,
                              arraysize(writes));
     HttpRequestInfo http_req = CreateGetRequest();
 
     NormalSpdyTransactionHelper helper(http_req, p, BoundNetLog(),
                                        GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
-    EXPECT_EQ(OK, out.rv);
+    EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
   }
 }
 
 // Start three gets simultaniously; making sure that multiplexed
 // streams work properly.
 
 // This can't use the TransactionHelper method, since it only
 // handles a single transaction, and finishes them as soon
@@ skipping 73 matching lines @@
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   TestCompletionCallback callback3;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
 
   out.rv = callback1.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
   out.rv = callback3.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
 
   trans2->GetResponseInfo();
 
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
   helper.VerifyDataConsumed();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBinding) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
@@ skipping 43 matching lines @@
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
 
   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
 
   out.rv = callback1.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
   out.rv = callback2.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   EXPECT_TRUE(response2->headers);
   EXPECT_TRUE(response2->was_fetched_via_spdy);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
   out.rv = ReadTransaction(trans2.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBindingFromPreconnect) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp(
@@ skipping 53 matching lines @@
 
   HttpRequestInfo httpreq = CreateGetRequest();
 
   // Preconnect the first.
   HttpStreamFactory* http_stream_factory =
       helper.session()->http_stream_factory();
 
   http_stream_factory->PreconnectStreams(1, httpreq);
 
   out.rv = trans1->Start(&httpreq, callback1.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   out.rv = trans2->Start(&httpreq, callback2.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
 
   out.rv = callback1.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
   out.rv = callback2.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   EXPECT_TRUE(response2->headers);
   EXPECT_TRUE(response2->was_fetched_via_spdy);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
   out.rv = ReadTransaction(trans2.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   helper.VerifyDataConsumed();
 }
 
 // Similar to ThreeGets above, however this test adds a SETTINGS
 // frame.  The SETTINGS frame is read during the IO loop waiting on
 // the first transaction completion, and sets a maximum concurrent
 // stream limit of 1.  This means that our IO loop exists after the
@@ skipping 83 matching lines @@
 
     HttpRequestInfo httpreq1 = CreateGetRequest();
     HttpRequestInfo httpreq2 = CreateGetRequest();
     HttpRequestInfo httpreq3 = CreateGetRequest();
 
     out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     // Run transaction 1 through quickly to force a read of our SETTINGS
     // frame.
     out.rv = callback1.WaitForResult();
-    ASSERT_EQ(OK, out.rv);
+    ASSERT_THAT(out.rv, IsOk());
 
     out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     out.rv = callback2.WaitForResult();
-    ASSERT_EQ(OK, out.rv);
+    ASSERT_THAT(out.rv, IsOk());
 
     out.rv = callback3.WaitForResult();
-    ASSERT_EQ(OK, out.rv);
+    ASSERT_THAT(out.rv, IsOk());
 
     const HttpResponseInfo* response1 = trans1->GetResponseInfo();
     ASSERT_TRUE(response1);
     EXPECT_TRUE(response1->headers);
     EXPECT_TRUE(response1->was_fetched_via_spdy);
     out.status_line = response1->headers->GetStatusLine();
     out.response_info = *response1;
     out.rv = ReadTransaction(trans1.get(), &out.response_data);
-    EXPECT_EQ(OK, out.rv);
+    EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!hello!", out.response_data);
 
     const HttpResponseInfo* response2 = trans2->GetResponseInfo();
     out.status_line = response2->headers->GetStatusLine();
     out.response_info = *response2;
     out.rv = ReadTransaction(trans2.get(), &out.response_data);
-    EXPECT_EQ(OK, out.rv);
+    EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!hello!", out.response_data);
 
     const HttpResponseInfo* response3 = trans3->GetResponseInfo();
     out.status_line = response3->headers->GetStatusLine();
     out.response_info = *response3;
     out.rv = ReadTransaction(trans3.get(), &out.response_data);
-    EXPECT_EQ(OK, out.rv);
+    EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!hello!", out.response_data);
 
     helper.VerifyDataConsumed();
   }
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
 }
 
 // Similar to ThreeGetsWithMaxConcurrent above, however this test adds
 // a fourth transaction.  The third and fourth transactions have
 // different data ("hello!" vs "hello!hello!") and because of the
 // user specified priority, we expect to see them inverted in
 // the response from the server.
 TEST_P(SpdyNetworkTransactionTest, FourGetsWithMaxConcurrentPriority) {
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
@@ skipping 88 matching lines @@
   TestCompletionCallback callback2;
   TestCompletionCallback callback3;
   TestCompletionCallback callback4;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
   HttpRequestInfo httpreq4 = CreateGetRequest();
 
   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   // Run transaction 1 through quickly to force a read of our SETTINGS frame.
   out.rv = callback1.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
   out.rv = trans4->Start(&httpreq4, callback4.callback(), log);
-  ASSERT_EQ(ERR_IO_PENDING, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_IO_PENDING));
 
   out.rv = callback2.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   out.rv = callback3.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
   out.rv = ReadTransaction(trans2.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   // notice: response3 gets two hellos, response4 gets one
   // hello, so we know dequeuing priority was respected.
   const HttpResponseInfo* response3 = trans3->GetResponseInfo();
   out.status_line = response3->headers->GetStatusLine();
   out.response_info = *response3;
   out.rv = ReadTransaction(trans3.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   out.rv = callback4.WaitForResult();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   const HttpResponseInfo* response4 = trans4->GetResponseInfo();
   out.status_line = response4->headers->GetStatusLine();
   out.response_info = *response4;
   out.rv = ReadTransaction(trans4.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
   helper.VerifyDataConsumed();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
 }
 
 // Similar to ThreeGetsMaxConcurrrent above, however, this test
 // deletes a session in the middle of the transaction to ensure
 // that we properly remove pendingcreatestream objects from
 // the spdy_session
 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentDelete) {
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
@@ skipping 59 matching lines @@
   TestCompletionCallback callback3;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   // Run transaction 1 through quickly to force a read of our SETTINGS frame.
   out.rv = callback1.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   trans3.reset();
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback2.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
   EXPECT_TRUE(response1->headers);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
   out.rv = ReadTransaction(trans2.get(), &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
   helper.VerifyDataConsumed();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
 }
 
 namespace {
 
 // The KillerCallback will delete the transaction on error as part of the
 // callback.
 class KillerCallback : public TestCompletionCallbackBase {
  public:
   explicit KillerCallback(HttpNetworkTransaction* transaction)
       : transaction_(transaction),
@@ skipping 85 matching lines @@
   KillerCallback callback3(trans3);
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
   out.rv = trans1.Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   // Run transaction 1 through quickly to force a read of our SETTINGS frame.
   out.rv = callback1.WaitForResult();
-  ASSERT_EQ(OK, out.rv);
+  ASSERT_THAT(out.rv, IsOk());
 
   out.rv = trans2.Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback3.WaitForResult();
-  ASSERT_EQ(ERR_ABORTED, out.rv);
+  ASSERT_THAT(out.rv, IsError(ERR_ABORTED));
 
   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
   ASSERT_TRUE(response1);
   EXPECT_TRUE(response1->headers);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(&trans1, &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
 
   const HttpResponseInfo* response2 = trans2.GetResponseInfo();
   ASSERT_TRUE(response2);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
   out.rv = ReadTransaction(&trans2, &out.response_data);
-  EXPECT_EQ(ERR_CONNECTION_RESET, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_CONNECTION_RESET));
 
   helper.VerifyDataConsumed();
 }
 
 // Test that a simple PUT request works.
 TEST_P(SpdyNetworkTransactionTest, Put) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = default_url_;
@@ skipping 15 matching lines @@
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
 }
 
 // Test that a simple HEAD request works.
 TEST_P(SpdyNetworkTransactionTest, Head) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = default_url_;
 
@@ skipping 14 matching lines @@
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, Post) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
       CreateMockRead(*resp, 2),
       CreateMockRead(*body, 3),
       MockRead(ASYNC, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreatePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a POST with a file works.
 TEST_P(SpdyNetworkTransactionTest, FilePost) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
       CreateMockRead(*resp, 2),
       CreateMockRead(*body, 3),
       MockRead(ASYNC, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateFilePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a POST with a unreadable file fails.
 TEST_P(SpdyNetworkTransactionTest, UnreadableFilePost) {
   MockWrite writes[] = {
       MockWrite(ASYNC, 0, 0)  // EOF
   };
   MockRead reads[] = {
       MockRead(ASYNC, 0, 1)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateUnreadableFilePostRequest(),
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   helper.RunDefaultTest();
 
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataNotConsumed();
-  EXPECT_EQ(ERR_ACCESS_DENIED, helper.output().rv);
+  EXPECT_THAT(helper.output().rv, IsError(ERR_ACCESS_DENIED));
 }
 
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionTest, ComplexPost) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
       CreateMockRead(*resp, 2),
       CreateMockRead(*body, 3),
       MockRead(ASYNC, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateComplexPostRequest(),
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a chunked POST works.
 TEST_P(SpdyNetworkTransactionTest, ChunkedPost) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
@@ skipping 15 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
 
   // These chunks get merged into a single frame when being sent.
   const int kFirstChunkSize = kUploadDataSize/2;
   upload_chunked_data_stream()->AppendData(kUploadData, kFirstChunkSize, false);
   upload_chunked_data_stream()->AppendData(
       kUploadData + kFirstChunkSize, kUploadDataSize - kFirstChunkSize, true);
 
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ(kUploadData, out.response_data);
 }
 
 // Test that a chunked POST works with chunks appended after transaction starts.
 TEST_P(SpdyNetworkTransactionTest, DelayedChunkedPost) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> chunk1(
       spdy_util_.ConstructSpdyBodyFrame(1, false));
@@ skipping 36 matching lines @@
 
   helper.FinishDefaultTest();
   helper.VerifyDataConsumed();
 
   std::string expected_response;
   expected_response += kUploadData;
   expected_response += kUploadData;
   expected_response += kUploadData;
 
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
 // Test that a POST without any post data works.
 TEST_P(SpdyNetworkTransactionTest, NullPost) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
@@ skipping 21 matching lines @@
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
   // Create an empty UploadDataStream.
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   ElementsUploadDataStream stream(std::move(element_readers), 0);
@@ skipping 24 matching lines @@
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // While we're doing a post, the server sends the reply before upload completes.
 TEST_P(SpdyNetworkTransactionTest, ResponseBeforePostCompletes) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
@@ skipping 23 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Process the request headers, SYN_REPLY, and response body.
   // The request body is still in flight.
   const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
 
   // Finish sending the request body.
   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
   helper.WaitForCallbackToComplete();
-  EXPECT_EQ(OK, helper.output().rv);
+  EXPECT_THAT(helper.output().rv, IsOk());
 
   std::string response_body;
-  EXPECT_EQ(OK, ReadTransaction(helper.trans(), &response_body));
+  EXPECT_THAT(ReadTransaction(helper.trans(), &response_body), IsOk());
   EXPECT_EQ(kUploadData, response_body);
   helper.VerifyDataConsumed();
 }
 
 // The client upon cancellation tries to send a RST_STREAM frame. The mock
 // socket causes the TCP write to return zero. This test checks that the client
 // tries to queue up the RST_STREAM frame again.
 TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
@@ skipping 15 matching lines @@
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(OK, callback.GetResult(rv));
+  EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   helper.ResetTrans();
   base::RunLoop().RunUntilIdle();
 
   helper.VerifyDataConsumed();
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*body, 1), MockRead(ASYNC, 0, 3)  // EOF
   };
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
   };
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 // Test that the transaction doesn't crash when we get two replies on the same
 // stream ID. See http://crbug.com/45639.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
@@ skipping 15 matching lines @@
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   std::string response_data;
   rv = ReadTransaction(trans, &response_data);
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
+  EXPECT_THAT(rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) {
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
@@ skipping 12 matching lines @@
       CreateMockRead(*resp, 1),
       CreateMockRead(*body, 3),
       MockRead(ASYNC, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) {
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
@@ skipping 17 matching lines @@
       CreateMockRead(*push, 2),
       CreateMockRead(*body, 3),
       MockRead(ASYNC, 0, 5)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, CancelledTransaction) {
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
@@ skipping 18 matching lines @@
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   helper.ResetTrans();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataNotConsumed();
 }
 
 // Verify that the client sends a Rst Frame upon cancelling the stream.
 TEST_P(SpdyNetworkTransactionTest, CancelledTransactionSendRst) {
@@ skipping 19 matching lines @@
                                      BoundNetLog(),
                                      GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(OK, callback.GetResult(rv));
+  EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   helper.ResetTrans();
   base::RunLoop().RunUntilIdle();
 
   helper.VerifyDataConsumed();
 }
 
 // Verify that the client can correctly deal with the user callback attempting
 // to start another transaction on a session that is closing down. See
 // http://crbug.com/47455
@@ skipping 32 matching lines @@
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   helper.AddData(&data2);
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
 
   const int kSize = 3000;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kSize));
   rv = trans->Read(
       buf.get(), kSize,
       base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback,
                  helper.session(), default_url_));
-  ASSERT_EQ(ERR_IO_PENDING, rv);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   // This forces an err_IO_pending, which sets the callback.
   data.Resume();
   data.RunUntilPaused();
 
   // This finishes the read.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
@@ skipping 20 matching lines @@
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
 
   // Setup a user callback which will delete the session, and clear out the
   // memory holding the stream object. Note that the callback deletes trans.
   const int kSize = 3000;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kSize));
   rv = trans->Read(
       buf.get(),
       kSize,
       base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback,
                  base::Unretained(&helper)));
-  ASSERT_EQ(ERR_IO_PENDING, rv);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   data.Resume();
 
   // Finish running rest of tasks.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
 // Send a spdy request to www.example.org that gets redirected to www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectGetRequest) {
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
@@ skipping 322 matching lines @@
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
@@ skipping 183 matching lines @@
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
@@ skipping 26 matching lines @@
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
@@ skipping 31 matching lines @@
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
@@ skipping 51 matching lines @@
                                      BoundNetLog(), GetParam(), nullptr);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv =
       trans->Start(&CreateGetRequest(), callback.callback(), BoundNetLog());
   rv = callback.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   VerifyStreamsClosed(helper);
 }
 
 // PUSH_PROMISE on a server-initiated stream should trigger GOAWAY even if
@@ skipping 30 matching lines @@
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), nullptr);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans1 = helper.trans();
   TestCompletionCallback callback1;
   int rv =
       trans1->Start(&CreateGetRequest(), callback1.callback(), BoundNetLog());
   rv = callback1.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   HttpResponseInfo response = *trans1->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   TestCompletionCallback callback2;
   rv = trans2->Start(&CreateGetPushRequest(), callback2.callback(),
                      BoundNetLog());
   rv = callback2.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   response = *trans2->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
   std::string result;
   ReadResult(trans2.get(), &result);
   EXPECT_EQ(kPushedData, result);
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
@@ skipping 64 matching lines @@
         MockRead(ASYNC, 0, 3)  // EOF
     };
 
     SequencedSocketData data(reads, arraysize(reads), writes,
                              arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
 
-    EXPECT_EQ(OK, out.rv);
+    EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
 
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
     EXPECT_TRUE(headers);
     size_t iter = 0;
     std::string name, value;
     SpdyHeaderBlock header_block;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       SpdyHeaderBlock::StringPieceProxy mutable_header_block_value =
@@ skipping 168 matching lines @@
     MockRead reads[] = {
         CreateMockRead(*resp, 1), MockRead(ASYNC, 0, 3)  // EOF
     };
 
     SequencedSocketData data(reads, arraysize(reads), writes,
                              arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
-    EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+    EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
   if (spdy_util_.spdy_version() != SPDY3) {
     return;
   }
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
@@ skipping 19 matching lines @@
       MockRead(ASYNC, syn_reply_wrong_length->data(),
                syn_reply_wrong_length->size(), 1),
       CreateMockRead(*body, 2),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), nullptr);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionErrorSpdy4) {
   if (spdy_util_.spdy_version() != HTTP2) {
     return;
   }
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
@@ skipping 14 matching lines @@
   MockRead reads[] = {
       MockRead(ASYNC, syn_reply_wrong_length->data(),
                syn_reply_wrong_length->size() - 4, 1),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_COMPRESSION_ERROR));
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnDecompressionFailure) {
   if (GetParam().protocol < kProtoHTTP2) {
     // Decompression failures are a stream error in SPDY3.
     return;
   }
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 6 (DECOMPRESS_FAILURE)."));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // Read HEADERS with corrupted payload.
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   memset(resp->data() + 12, 0xcf, resp->size() - 12);
   MockRead reads[] = {CreateMockRead(*resp, 1)};
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_COMPRESSION_ERROR));
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnFrameSizeError) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_FRAME_SIZE_ERROR,
       "Framer error: 15 (INVALID_CONTROL_FRAME_SIZE)."));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // Read WINDOW_UPDATE with incorrectly-sized payload.
   std::unique_ptr<SpdySerializedFrame> bad_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, 1));
   test::SetFrameLength(bad_window_update.get(),
                        bad_window_update->size() - 1,
                        spdy_util_.spdy_version());
   MockRead reads[] = {CreateMockRead(*bad_window_update, 1)};
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_FRAME_SIZE_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_FRAME_SIZE_ERROR));
 }
 
 // Test that we shutdown correctly on write errors.
 TEST_P(SpdyNetworkTransactionTest, WriteError) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
       // We'll write 10 bytes successfully
       MockWrite(ASYNC, req->data(), 10, 1),
       // Followed by ERROR!
       MockWrite(ASYNC, ERR_FAILED, 2),
       // Session drains and attempts to write a GOAWAY: Another ERROR!
       MockWrite(ASYNC, ERR_FAILED, 3),
   };
 
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   EXPECT_TRUE(helper.StartDefaultTest());
   helper.FinishDefaultTest();
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data.AllReadDataConsumed());
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_FAILED, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_FAILED));
 }
 
 // Test that partial writes work.
 TEST_P(SpdyNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   const int kChunks = 5;
   std::unique_ptr<MockWrite[]> writes(ChopWriteFrame(*req.get(), kChunks));
   for (int i = 0; i < kChunks; ++i) {
     writes[i].sequence_number = i;
   }
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, kChunks),
       CreateMockRead(*body, kChunks + 1),
       MockRead(ASYNC, 0, kChunks + 2)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes.get(), kChunks);
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that the NetLog contains good data for a simple GET request.
 TEST_P(SpdyNetworkTransactionTest, NetLog) {
   static const char* const kExtraHeaders[] = {
     "user-agent",   "Chrome",
   };
   std::unique_ptr<SpdySerializedFrame> req(
@@ skipping 11 matching lines @@
   };
 
   BoundTestNetLog log;
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequestWithUserAgent(),
                                      DEFAULT_PRIORITY,
                                      log.bound(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   // Check that the NetLog was filled reasonably.
   // This test is intentionally non-specific about the exact ordering of the
   // log; instead we just check to make sure that certain events exist, and that
   // they are in the right order.
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
@@ skipping 91 matching lines @@
 
   TestCompletionCallback callback;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 20 matching lines @@
 
   out.response_data.swap(content);
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::RunLoop().RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("goodbye world", out.response_data);
 }
 
 // Verify that basic buffering works; when multiple data frames arrive
 // at the same time, ensure that we don't notify a read completion for
 // each data frame individually.
 TEST_P(SpdyNetworkTransactionTest, Buffering) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
 
@@ skipping 27 matching lines @@
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 25 matching lines @@
 
   out.response_data.swap(content);
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::RunLoop().RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
@@ skipping 23 matching lines @@
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 21 matching lines @@
 
   out.response_data.swap(content);
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::RunLoop().RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data and close the connection.
 TEST_P(SpdyNetworkTransactionTest, BufferedClosed) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
@@ skipping 23 matching lines @@
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == ERR_IO_PENDING) {
       data.Resume();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       // This test intentionally closes the connection, and will get an error.
-      EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
+      EXPECT_THAT(rv, IsError(ERR_CONNECTION_CLOSED));
       break;
     }
     reads_completed++;
   } while (rv > 0);
 
   EXPECT_EQ(0, reads_completed);
 
   out.response_data.swap(content);
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
@@ skipping 31 matching lines @@
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 94 matching lines @@
       CreateMockRead(*body, 2),
       CreateMockRead(*settings_frame, 3),
       MockRead(ASYNC, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.AddData(&data);
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
     const SettingsMap& settings_map =
         spdy_session_pool->http_server_properties()->GetSpdySettings(
             spdy_server);
     ASSERT_EQ(2u, settings_map.size());
 
@@ skipping 102 matching lines @@
       CreateMockRead(*reply, 3),
       CreateMockRead(*body, 4),
       MockRead(ASYNC, 0, 5)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.AddData(&data);
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
     const SettingsMap& settings_map =
         spdy_session_pool->http_server_properties()->GetSpdySettings(
             spdy_server);
     ASSERT_EQ(2u, settings_map.size());
 
@@ skipping 23 matching lines @@
   MockRead reads[] = {
       CreateMockRead(*go_away, 1),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_ABORTED, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_ABORTED));
 }
 
 TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
@@ skipping 13 matching lines @@
   out.rv = trans->Start(&CreateGetRequest(), callback.callback(), log);
 
   EXPECT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_CONNECTION_CLOSED));
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // HTTP_1_1_REQUIRED results in ERR_HTTP_1_1_REQUIRED.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredError) {
   // HTTP_1_1_REQUIRED is only supported by HTTP/2.
   if (spdy_util_.spdy_version() < HTTP2)
     return;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), nullptr);
 
   std::unique_ptr<SpdySerializedFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads[] = {
       CreateMockRead(*go_away, 0),
   };
   SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
 
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_HTTP_1_1_REQUIRED, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_HTTP_1_1_REQUIRED));
 }
 
 // Retry with HTTP/1.1 when receiving HTTP_1_1_REQUIRED.  Note that no actual
 // protocol negotiation happens, instead this test forces protocols for both
 // sockets.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredRetry) {
   // HTTP_1_1_REQUIRED is only supported by HTTP/2.
   if (spdy_util_.spdy_version() < HTTP2)
     return;
 
@@ skipping 61 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1, response->connection_info);
   EXPECT_TRUE(response->was_npn_negotiated);
   EXPECT_TRUE(request.url.SchemeIs("https"));
   EXPECT_EQ("127.0.0.1", response->socket_address.host());
   EXPECT_EQ(443, response->socket_address.port());
   std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(helper.trans(), &response_data));
+  ASSERT_THAT(ReadTransaction(helper.trans(), &response_data), IsOk());
   EXPECT_EQ("hello", response_data);
 }
 
 // Retry with HTTP/1.1 to the proxy when receiving HTTP_1_1_REQUIRED from the
 // proxy.  Note that no actual protocol negotiation happens, instead this test
 // forces protocols for both sockets.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredProxyRetry) {
   // HTTP_1_1_REQUIRED is only supported by HTTP/2.
   if (spdy_util_.spdy_version() < HTTP2)
     return;
@@ skipping 80 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1, response->connection_info);
   EXPECT_FALSE(response->was_npn_negotiated);
   EXPECT_TRUE(request.url.SchemeIs("https"));
   EXPECT_EQ("127.0.0.1", response->socket_address.host());
   EXPECT_EQ(70, response->socket_address.port());
   std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(helper.trans(), &response_data));
+  ASSERT_THAT(ReadTransaction(helper.trans(), &response_data), IsOk());
   EXPECT_EQ("hello", response_data);
 }
 
 // Test to make sure we can correctly connect through a proxy.
 TEST_P(SpdyNetworkTransactionTest, ProxyConnect) {
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.session_deps() = CreateSpdySessionDependencies(
       GetParam(), ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   helper.SetSession(
@@ skipping 24 matching lines @@
       MockRead(ASYNC, 0, 0, 5),
   };
   std::unique_ptr<SequencedSocketData> data(new SequencedSocketData(
       reads, arraysize(reads), writes, arraysize(writes)));
 
   helper.AddData(data.get());
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   ASSERT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(trans, &response_data));
+  ASSERT_THAT(ReadTransaction(trans, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
   helper.VerifyDataConsumed();
 }
 
 // Test to make sure we can correctly connect through a proxy to
 // www.example.org, if there already exists a direct spdy connection to
 // www.example.org. See https://crbug.com/49874.
 TEST_P(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
   // When setting up the first transaction, we store the SpdySessionPool so that
   // we can use the same pool in the second transaction.
@@ skipping 39 matching lines @@
       &CreateGetRequest(), callback.callback(), BoundNetLog());
 
   EXPECT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   out.status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   // Check that the SpdySession is still in the SpdySessionPool.
   SpdySessionKey session_pool_key_direct(host_port_pair_, ProxyServer::Direct(),
                                          PRIVACY_MODE_DISABLED);
   EXPECT_TRUE(HasSpdySession(spdy_session_pool, session_pool_key_direct));
   SpdySessionKey session_pool_key_proxy(
       host_port_pair_,
@@ skipping 51 matching lines @@
   session_peer.SetProxyService(proxy_service.get());
   helper_proxy.session_deps().swap(ssd_proxy);
   helper_proxy.SetSession(std::move(session_proxy));
   helper_proxy.RunPreTestSetup();
   helper_proxy.AddData(data_proxy.get());
 
   HttpNetworkTransaction* trans_proxy = helper_proxy.trans();
   TestCompletionCallback callback_proxy;
   int rv = trans_proxy->Start(
       &request_proxy, callback_proxy.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback_proxy.WaitForResult();
   EXPECT_EQ(0, rv);
 
   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
   ASSERT_TRUE(response_proxy.headers);
   EXPECT_EQ("HTTP/1.1 200", response_proxy.headers->GetStatusLine());
 
   std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(trans_proxy, &response_data));
+  ASSERT_THAT(ReadTransaction(trans_proxy, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
 
   helper_proxy.VerifyDataConsumed();
 }
 
 // When we get a TCP-level RST, we need to retry a HttpNetworkTransaction
 // on a new connection, if the connection was previously known to be good.
 // This can happen when a server reboots without saying goodbye, or when
 // we're behind a NAT that masked the RST.
 TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) {
@@ skipping 47 matching lines @@
     helper.AddData(&data2);
     helper.RunPreTestSetup();
 
     for (int i = 0; i < 2; ++i) {
       std::unique_ptr<HttpNetworkTransaction> trans(
           new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
 
       TestCompletionCallback callback;
       int rv = trans->Start(
           &helper.request(), callback.callback(), BoundNetLog());
-      EXPECT_EQ(ERR_IO_PENDING, rv);
+      EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
       // On the second transaction, we trigger the RST.
       if (i == 1) {
         if (variant == VARIANT_RST_DURING_READ_COMPLETION) {
           // Writes to the socket complete asynchronously on SPDY by running
           // through the message loop.  Complete the write here.
           base::RunLoop().RunUntilIdle();
         }
 
         // Now schedule the ERR_CONNECTION_RESET.
         data1.Resume();
       }
       rv = callback.WaitForResult();
-      EXPECT_EQ(OK, rv);
+      EXPECT_THAT(rv, IsOk());
 
       const HttpResponseInfo* response = trans->GetResponseInfo();
       ASSERT_TRUE(response);
       EXPECT_TRUE(response->headers);
       EXPECT_TRUE(response->was_fetched_via_spdy);
       std::string response_data;
       rv = ReadTransaction(trans.get(), &response_data);
-      EXPECT_EQ(OK, rv);
+      EXPECT_THAT(rv, IsOk());
       EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
       EXPECT_EQ("hello!", response_data);
       base::RunLoop().RunUntilIdle();
     }
 
     helper.VerifyDataConsumed();
     base::RunLoop().RunUntilIdle();
   }
 }
 
@@ skipping 13 matching lines @@
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                            arraysize(spdy_writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   HttpStreamFactory::set_spdy_enabled(false);
   MockWrite http_writes[] = {
       MockWrite(SYNCHRONOUS, 0,
                 "GET / HTTP/1.1\r\n"
                 "Host: www.example.org\r\n"
                 "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead http_reads[] = {
       MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
       MockRead(SYNCHRONOUS, 2, "hello from http"),
       MockRead(SYNCHRONOUS, OK, 3),
   };
   SequencedSocketData data2(http_reads, arraysize(http_reads), http_writes,
                             arraysize(http_writes));
   NormalSpdyTransactionHelper helper2(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper2.SetSpdyDisabled();
   helper2.RunToCompletion(&data2);
   TransactionHelperResult out2 = helper2.output();
-  EXPECT_EQ(OK, out2.rv);
+  EXPECT_THAT(out2.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line);
   EXPECT_EQ("hello from http", out2.response_data);
 
   HttpStreamFactory::set_spdy_enabled(true);
 }
 
 // Tests that Basic authentication works over SPDY
 TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) {
   HttpStreamFactory::set_spdy_enabled(true);
 
@@ skipping 44 matching lines @@
   HttpRequestInfo request(CreateGetRequest());
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      net_log, GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
   const int rv_start = trans->Start(&request, callback.callback(), net_log);
-  EXPECT_EQ(ERR_IO_PENDING, rv_start);
+  EXPECT_THAT(rv_start, IsError(ERR_IO_PENDING));
   const int rv_start_complete = callback.WaitForResult();
-  EXPECT_EQ(OK, rv_start_complete);
+  EXPECT_THAT(rv_start_complete, IsOk());
 
   // Make sure the response has an auth challenge.
   const HttpResponseInfo* const response_start = trans->GetResponseInfo();
   ASSERT_TRUE(response_start);
   ASSERT_TRUE(response_start->headers);
   EXPECT_EQ(401, response_start->headers->response_code());
   EXPECT_TRUE(response_start->was_fetched_via_spdy);
   AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get();
   ASSERT_TRUE(auth_challenge);
   EXPECT_FALSE(auth_challenge->is_proxy);
   EXPECT_EQ(kBasicAuthScheme, auth_challenge->scheme);
   EXPECT_EQ("MyRealm", auth_challenge->realm);
 
   // Restart with a username/password.
   AuthCredentials credentials(base::ASCIIToUTF16("foo"),
                               base::ASCIIToUTF16("bar"));
   TestCompletionCallback callback_restart;
   const int rv_restart = trans->RestartWithAuth(
       credentials, callback_restart.callback());
-  EXPECT_EQ(ERR_IO_PENDING, rv_restart);
+  EXPECT_THAT(rv_restart, IsError(ERR_IO_PENDING));
   const int rv_restart_complete = callback_restart.WaitForResult();
-  EXPECT_EQ(OK, rv_restart_complete);
+  EXPECT_THAT(rv_restart_complete, IsOk());
   // TODO(cbentzel): This is actually the same response object as before, but
   // data has changed.
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
   ASSERT_TRUE(response_restart);
   ASSERT_TRUE(response_restart->headers);
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) {
@@ skipping 101 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // and the body of the primary stream, but before we've received the HEADERS
   // for the pushed stream.
   data.RunUntilPaused();
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   data.Resume();
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
   std::string result2;
   ReadResult(trans2.get(), &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, &result);
@@ skipping 95 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // the first HEADERS frame, and the body of the primary stream, but before
   // we've received the final HEADERS for the pushed stream.
   data.RunUntilPaused();
   EXPECT_EQ(0, callback.WaitForResult());
 
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   data.Resume();
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
   // This is needed to work around https://crbug.com/571102.
   data.Resume();
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
   std::string result2;
@@ skipping 80 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // the first HEADERS frame, and the body of the primary stream, but before
   // we've received the final HEADERS for the pushed stream.
   data.RunUntilPaused();
   EXPECT_EQ(0, callback.WaitForResult());
 
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   data.Resume();
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
   std::string result2;
   ReadResult(trans2.get(), &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, &result);
@@ skipping 45 matching lines @@
       CreateMockRead(*stream1_headers, 2),
       CreateMockRead(*stream1_body, 3),
       MockRead(ASYNC, 0, 5)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 // Tests that receiving HEADERS, DATA, HEADERS, and DATA in that sequence will
 // trigger a ERR_SPDY_PROTOCOL_ERROR because trailing HEADERS must not be
 // followed by any DATA frames.
 TEST_P(SpdyNetworkTransactionTest, SyncReplyDataAfterTrailers) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
@@ skipping 17 matching lines @@
       CreateMockRead(*stream1_reply, 1), CreateMockRead(*stream1_body, 2),
       CreateMockRead(*stream1_headers, 3), CreateMockRead(*stream1_body2, 4),
       MockRead(ASYNC, 0, 6)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) {
   // In this test we want to verify that we can't accidentally push content
   // which can't be pushed by this content server.
   // This test assumes that:
   //   - if we're requesting http://www.foo.com/barbaz
   //   - the browser has made a connection to "www.foo.com".
 
   // A list of the URL to fetch, followed by the URL being pushed.
@@ skipping 67 matching lines @@
                                        GetParam(), std::move(session_deps));
     helper.RunPreTestSetup();
     helper.AddData(&data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     rv = callback.WaitForResult();
 
     // Read the response body.
     std::string result;
     ReadResult(trans, &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data.AllReadDataConsumed());
     EXPECT_TRUE(data.AllWriteDataConsumed());
 
@@ skipping 50 matching lines @@
   BoundNetLog log;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, log, GetParam(),
                                      nullptr);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans0 = helper.trans();
   TestCompletionCallback callback0;
   int rv = trans0->Start(&request, callback0.callback(), log);
   rv = callback0.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   SpdySessionKey key(host_port_pair_, ProxyServer::Direct(),
                      PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session =
       spdy_session_pool->FindAvailableSession(key, GURL(), log);
 
   EXPECT_FALSE(spdy_session->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(1u, spdy_session->unclaimed_pushed_streams_.size());
   EXPECT_EQ(1u,
             spdy_session->unclaimed_pushed_streams_.count(GURL(url_to_push)));
 
   std::unique_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   HttpRequestInfo push_request;
   push_request.method = "GET";
   push_request.url = GURL(url_to_push);
   push_request.load_flags = 0;
   TestCompletionCallback callback1;
   rv = trans1->Start(&push_request, callback1.callback(), log);
   rv = callback1.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   EXPECT_TRUE(spdy_session->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session->unclaimed_pushed_streams_.size());
 
   helper.VerifyDataConsumed();
   VerifyStreamsClosed(helper);
 
   HttpResponseInfo response = *trans0->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
@@ skipping 96 matching lines @@
   std::unique_ptr<SSLSocketDataProvider> ssl_provider1(
       new SSLSocketDataProvider(ASYNC, OK));
   ssl_provider1->cert =
       ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
   helper.AddDataWithSSLSocketDataProvider(&data1, std::move(ssl_provider1));
 
   HttpNetworkTransaction* trans0 = helper.trans();
   TestCompletionCallback callback0;
   int rv = trans0->Start(&request0, callback0.callback(), log);
   rv = callback0.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Request |url_to_fetch1|, during which docs.example.org pushes
   // |url_to_push|, which happens to be for www.example.org, to which there is
   // already an open connection.
   std::unique_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL(url_to_fetch1);
   request1.load_flags = 0;
   TestCompletionCallback callback1;
   rv = trans1->Start(&request1, callback1.callback(), log);
   rv = callback1.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   HostPortPair host_port_pair0("mail.example.org", 443);
   SpdySessionKey key0(host_port_pair0, ProxyServer::Direct(),
                       PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session0 =
       spdy_session_pool->FindAvailableSession(key0, GURL(), log);
 
   EXPECT_TRUE(spdy_session0->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session0->unclaimed_pushed_streams_.size());
@@ skipping 12 matching lines @@
   // Request |url_to_push|, which should be served from the pushed resource.
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
   HttpRequestInfo push_request;
   push_request.method = "GET";
   push_request.url = GURL(url_to_push);
   push_request.load_flags = 0;
   TestCompletionCallback callback2;
   rv = trans2->Start(&push_request, callback2.callback(), log);
   rv = callback2.GetResult(rv);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   EXPECT_TRUE(spdy_session0->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session0->unclaimed_pushed_streams_.size());
 
   EXPECT_TRUE(spdy_session1->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session1->unclaimed_pushed_streams_.size());
 
   helper.VerifyDataConsumed();
   VerifyStreamsClosed(helper);
 
@@ skipping 101 matching lines @@
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
@@ skipping 50 matching lines @@
   NormalSpdyTransactionHelper helper(CreateGetRequest(), LOWEST,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   // Start the first transaction to set up the SpdySession
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
   HttpRequestInfo info1 = CreateGetRequest();
   int rv = trans->Start(&info1, callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Run the message loop, but do not allow the write to complete.
   // This leaves the SpdySession with a write pending, which prevents
   // SpdySession from attempting subsequent writes until this write completes.
   base::RunLoop().RunUntilIdle();
 
   // Now, start both new transactions
   HttpRequestInfo info2 = CreateGetRequest();
   TestCompletionCallback callback2;
   std::unique_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(MEDIUM, helper.session()));
   rv = trans2->Start(&info2, callback2.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   base::RunLoop().RunUntilIdle();
 
   HttpRequestInfo info3 = CreateGetRequest();
   TestCompletionCallback callback3;
   std::unique_ptr<HttpNetworkTransaction> trans3(
       new HttpNetworkTransaction(HIGHEST, helper.session()));
   rv = trans3->Start(&info3, callback3.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   base::RunLoop().RunUntilIdle();
 
   // We now have two SYN_STREAM frames queued up which will be
   // dequeued only once the first write completes, which we
   // now allow to happen.
   ASSERT_TRUE(data.IsPaused());
   data.Resume();
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // And now we can allow everything else to run to completion.
   data.Resume();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(OK, callback2.WaitForResult());
-  EXPECT_EQ(OK, callback3.WaitForResult());
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
+  EXPECT_THAT(callback3.WaitForResult(), IsOk());
 
   helper.VerifyDataConsumed();
 }
 
 // The tests below are only for SPDY/3 and above.
 
 // Test that sent data frames and received WINDOW_UPDATE frames change
 // the send_window_size_ correctly.
 
 // WINDOW_UPDATE is different than most other frames in that it can arrive
@@ skipping 70 matching lines @@
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
   EXPECT_EQ(static_cast<int>(
                 SpdySession::GetDefaultInitialWindowSize(GetParam().protocol)) +
                 kDeltaWindowSize * kDeltaCount -
                 kMaxSpdyFrameChunkSize * kFrameCount,
             stream->stream()->send_window_size());
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   helper.VerifyDataConsumed();
 }
 
 // Test that received data frames and sent WINDOW_UPDATE frames change
 // the recv_window_size_ correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) {
   const int32_t default_initial_window_size =
       SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
   // Session level maximum window size that is more than twice the default
@@ skipping 85 matching lines @@
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
   pool_peer.SetEnableSendingInitialData(true);
   pool_peer.SetSessionMaxRecvWindowSize(session_max_recv_window_size);
   pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size);
 
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   SpdyHttpStream* stream =
       static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
 
   // All data has been read, but not consumed. The window reflects this.
   EXPECT_EQ(static_cast<int>(stream_max_recv_window_size - kTargetSize),
             stream->stream()->recv_window_size());
 
@@ skipping 64 matching lines @@
   request.upload_data_stream = &upload_data_stream;
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  ASSERT_EQ(ERR_IO_PENDING, rv);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SPDY_PROTOCOL_ERROR));
   helper.VerifyDataConsumed();
 }
 
 // Test that after hitting a send window size of 0, the write process
 // stalls and upon receiving WINDOW_UPDATE frame write resumes.
 
 // This test constructs a POST request followed by enough data frames
 // containing 'a' that would make the window size 0, followed by another
 // data frame containing default content (which is "hello!") and this frame
 // also contains a FIN flag.  SequencedSocketData is used to enforce all
@@ skipping 117 matching lines @@
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   base::RunLoop().RunUntilIdle();  // Write as much as we can.
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
   EXPECT_EQ(0, stream->stream()->send_window_size());
   if (initial_window_size % kBufferSize != 0) {
     // If it does not take whole number of full upload buffer to zero out
     // initial window size, then the upload data is not at EOF, because the
@@ skipping 138 matching lines @@
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   data.RunUntilPaused();  // Write as much as we can.
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
   EXPECT_EQ(0, stream->stream()->send_window_size());
 
   if (initial_window_size % kBufferSize != 0) {
@@ skipping 147 matching lines @@
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   data.RunUntilPaused();  // Write as much as we can.
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
   EXPECT_EQ(0, stream->stream()->send_window_size());
 
   if (initial_window_size % kBufferSize != 0) {
@@ skipping 28 matching lines @@
       0, GOAWAY_PROTOCOL_ERROR, "Odd push stream id."));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 TEST_P(SpdyNetworkTransactionTest,
        GoAwayOnPushStreamIdLesserOrEqualThanLastAccepted) {
   std::unique_ptr<SpdySerializedFrame> push_a(spdy_util_.ConstructSpdyPush(
       NULL, 0, 4, 1, GetDefaultUrlWithPath("/a.dat").c_str()));
   SpdyHeaderBlock push_b_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/b.dat"),
                                  &push_b_headers);
   std::unique_ptr<SpdySerializedFrame> push_b(
@@ skipping 10 matching lines @@
       "New push stream id must be greater than the last accepted."));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 3),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
+  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 // Regression test for https://crbug.com/493348: request header exceeds 16 kB
 // and thus sent in multiple frames when using HTTP/2.
 TEST_P(SpdyNetworkTransactionTest, LargeRequest) {
   const std::string kKey("foo");
   const std::string kValue(1 << 15, 'z');
 
   HttpRequestInfo request;
   request.method = "GET";
@@ skipping 17 matching lines @@
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), nullptr);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Regression test for https://crbug.com/535629: response header exceeds 16 kB.
 TEST_P(SpdyNetworkTransactionTest, LargeResponseHeader) {
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes[] = {
@@ skipping 19 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = default_url_;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), nullptr);
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
-  EXPECT_EQ(OK, out.rv);
+  EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
   ASSERT_TRUE(out.response_info.headers->HasHeaderValue(kKey, kValue));
 }
 
 class SpdyNetworkTransactionNoTLSUsageCheckTest
     : public SpdyNetworkTransactionTest {
  protected:
   void RunNoTLSUsageCheckTest(
       std::unique_ptr<SSLSocketDataProvider> ssl_provider) {
@@ skipping 14 matching lines @@
 
     SequencedSocketData data(reads, arraysize(reads), writes,
                              arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
     request.url = default_url_;
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
-    EXPECT_EQ(OK, out.rv);
+    EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(
     Spdy,
     SpdyNetworkTransactionNoTLSUsageCheckTest,
     ::testing::Values(SpdyNetworkTransactionTestParams(kProtoSPDY31,
                                                        false)));
@@ skipping 26 matching lines @@
     MockWrite writes[] = {CreateMockWrite(*goaway)};
 
     StaticSocketDataProvider data(NULL, 0, writes, arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
     request.url = default_url_;
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
-    EXPECT_EQ(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY, out.rv);
+    EXPECT_THAT(out.rv, IsError(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY));
   }
 };
 
 INSTANTIATE_TEST_CASE_P(
     Spdy,
     SpdyNetworkTransactionTLSUsageCheckTest,
     ::testing::Values(SpdyNetworkTransactionTestParams(kProtoHTTP2, false),
                       SpdyNetworkTransactionTestParams(kProtoHTTP2, true)));
 
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSVersionTooOld) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_SSL3,
                                 &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net