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

net/quic/quic_http_stream_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_http_stream.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 33 matching lines @@
 #include "net/quic/test_tools/quic_test_packet_maker.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/test_task_runner.h"
 #include "net/socket/socket_performance_watcher.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/test/cert_test_util.h"
+#include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 using std::string;
 using testing::_;
 using testing::AnyNumber;
 using testing::Return;
 
 namespace net {
 namespace test {
 namespace {
 
 const char kUploadData[] = "Really nifty data!";
@@ skipping 517 matching lines @@
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   SetResponse("404 Not Found", string());
   size_t spdy_response_header_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, kFin, &spdy_response_header_frame_length));
 
   // Now that the headers have been processed, the callback will return.
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(404, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
   EXPECT_FALSE(response_.response_time.is_null());
   EXPECT_FALSE(response_.request_time.is_null());
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0,
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
@@ skipping 24 matching lines @@
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
 
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   SetResponse("200 OK", string());
 
   // Send the response headers.
   size_t spdy_response_header_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacketWithOffset(
       2, !kFin, &spdy_response_header_frame_length, &offset));
   // Now that the headers have been processed, the callback will return.
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
   EXPECT_FALSE(response_.response_time.is_null());
   EXPECT_FALSE(response_.request_time.is_null());
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(
       ConstructServerDataPacket(3, false, !kFin, /*offset=*/0, kResponseBody));
@@ skipping 57 matching lines @@
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   response_headers_[":status"] = "200 OK";
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_["content-type"] = "text/plain";
   response_headers_["big6"] = string(1000, 'x');  // Lots of x's.
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, kFin, &spdy_response_headers_frame_length));
 
   // Now that the headers have been processed, the callback will return.
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0,
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
@@ skipping 66 matching lines @@
   request_.url = GURL("http://www.example.org/");
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   EXPECT_TRUE(QuicHttpStreamPeer::WasHandshakeConfirmed(stream_.get()));
 
   QuicConnectionCloseFrame frame;
   frame.error_code = QUIC_PEER_GOING_AWAY;
   session_->connection()->OnConnectionCloseFrame(frame);
 
   NetErrorDetails details;
   EXPECT_EQ(QUIC_NO_ERROR, details.quic_connection_error);
   stream_->PopulateNetErrorDetails(&details);
@@ skipping 13 matching lines @@
   request_.url = GURL("http://www.example.org/");
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   // The test setup defaults handshake to be confirmed. Manually set
   // it to be not confirmed.
   // Granular errors shouldn't be reported if handshake not confirmed.
   QuicHttpStreamPeer::SetHandshakeConfirmed(stream_.get(), false);
 
   EXPECT_FALSE(QuicHttpStreamPeer::WasHandshakeConfirmed(stream_.get()));
   QuicConnectionCloseFrame frame;
   frame.error_code = QUIC_PEER_GOING_AWAY;
   session_->connection()->OnConnectionCloseFrame(frame);
@@ skipping 44 matching lines @@
 
   Initialize();
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(base::WrapUnique(
       new UploadBytesElementReader(kUploadData, strlen(kUploadData))));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
   request_.method = "POST";
   request_.url = GURL("http://www.example.org/");
   request_.upload_data_stream = &upload_data_stream;
-  ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+  ASSERT_THAT(request_.upload_data_stream->Init(CompletionCallback()), IsOk());
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack both packets in the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", string());
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously.
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructServerDataPacket(3, false, kFin, 0, kResponseBody));
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
@@ skipping 34 matching lines @@
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
                     TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   upload_data_stream.AppendData(kUploadData, chunk_size, true);
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   // Ack both packets in the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", string());
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructServerDataPacket(
       3, false, kFin, response_data_.length(), kResponseBody));
 
   // Since the body has already arrived, this should return immediately.
@@ skipping 35 matching lines @@
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
                     TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   upload_data_stream.AppendData(nullptr, 0, true);
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", string());
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructServerDataPacket(
       3, false, kFin, response_data_.length(), kResponseBody));
 
   // The body has arrived, but it is delivered asynchronously
@@ skipping 30 matching lines @@
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
                     TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   upload_data_stream.AppendData(nullptr, 0, true);
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", string());
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructServerDataPacket(
       3, false, kFin, response_data_.length(), kResponseBody));
 
   // The body has arrived, but it is delivered asynchronously
@@ skipping 26 matching lines @@
   request_.url = GURL("http://www.example.org/");
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(ConstructResponseHeadersPacket(2, kFin, nullptr));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(AtEof());
 
@@ skipping 28 matching lines @@
 
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Check that priority has now dropped back to MEDIUM.
   DCHECK_EQ(MEDIUM,
             ConvertQuicPriorityToRequestPriority(reliable_stream->priority()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
-  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(ConstructResponseHeadersPacket(2, kFin, nullptr));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(AtEof());
 
@@ skipping 123 matching lines @@
   // with the promised stream.
   EXPECT_EQ(OK, promised_stream_->SendRequest(headers_, &response_,
                                               callback_.callback()));
 
   EXPECT_EQ(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
       promise_id_);
 
   // The headers will be immediately available.
-  EXPECT_EQ(OK, promised_stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(promised_stream_->ReadResponseHeaders(callback_.callback()),
+              IsOk());
 
   // As will be the body.
   EXPECT_EQ(
       static_cast<int>(strlen(kResponseBody)),
       promised_stream_->ReadResponseBody(
           read_buffer_.get(), read_buffer_->size(), callback_.callback()));
   EXPECT_TRUE(promised_stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   EXPECT_EQ(0, stream_->GetTotalSentBytes());
@@ skipping 43 matching lines @@
   // Receive the promised response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(InnerConstructDataPacket(2, promise_id_, false, kFin, 0,
                                          kResponseBody, &server_maker_));
 
   base::RunLoop().RunUntilIdle();
 
   // Rendezvous should have succeeded now, so the promised stream
   // should point at our push stream, and we should be able read
   // headers and data from it.
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   EXPECT_EQ(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
       promise_id_);
 
-  EXPECT_EQ(OK, promised_stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(promised_stream_->ReadResponseHeaders(callback_.callback()),
+              IsOk());
 
   EXPECT_EQ(
       static_cast<int>(strlen(kResponseBody)),
       promised_stream_->ReadResponseBody(
           read_buffer_.get(), read_buffer_->size(), callback_.callback()));
 
   // Callback should return
   EXPECT_TRUE(promised_stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
@@ skipping 51 matching lines @@
   // with the promised stream.
   EXPECT_EQ(OK, promised_stream_->SendRequest(headers_, &response_,
                                               callback_.callback()));
 
   EXPECT_EQ(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
       promise_id_);
 
   // The headers will be immediately available.
-  EXPECT_EQ(OK, promised_stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(promised_stream_->ReadResponseHeaders(callback_.callback()),
+              IsOk());
 
   // As will be the body.
   EXPECT_EQ(
       static_cast<int>(strlen(kResponseBody)),
       promised_stream_->ReadResponseBody(
           read_buffer_.get(), read_buffer_->size(), callback_.callback()));
   EXPECT_TRUE(promised_stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   EXPECT_EQ(0, stream_->GetTotalSentBytes());
@@ skipping 75 matching lines @@
   // Receive the promised response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(InnerConstructDataPacket(2, promise_id_, false, kFin, 0,
                                          kResponseBody, &server_maker_));
 
   base::RunLoop().RunUntilIdle();
 
   // Rendezvous should have succeeded now, so the promised stream
   // should point at our push stream, and we should be able read
   // headers and data from it.
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   EXPECT_EQ(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
       promise_id_);
 
-  EXPECT_EQ(OK, promised_stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(promised_stream_->ReadResponseHeaders(callback_.callback()),
+              IsOk());
 
   EXPECT_EQ(
       static_cast<int>(strlen(kResponseBody)),
       promised_stream_->ReadResponseBody(
           read_buffer_.get(), read_buffer_->size(), callback_.callback()));
 
   // Callback should return
   EXPECT_TRUE(promised_stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
@@ skipping 57 matching lines @@
   response_headers_ = promised_response_.Clone();
   size_t spdy_response_headers_frame_length;
   ProcessPacket(InnerConstructResponseHeadersPacket(
       1, promise_id_, false, &spdy_response_headers_frame_length));
 
   base::RunLoop().RunUntilIdle();
 
   // Rendezvous should have failed due to vary mismatch, so the
   // promised stream should have been aborted, and instead we have a
   // new, regular client initiated stream.
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   // Not a server-initiated stream.
   EXPECT_NE(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
       promise_id_);
 
   // Instead, a new client-initiated stream.
   EXPECT_EQ(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
       stream_id_ + 2);
 
   // After rendezvous failure, the push stream has been cancelled.
   EXPECT_EQ(session_->GetPromisedByUrl(promise_url_), nullptr);
 
   // The rest of the test verifies that the retried as
   // client-initiated version of |promised_stream_| works as intended.
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(2, 0, 0));
 
   SetResponse("404 Not Found", string());
   size_t spdy_response_header_frame_length;
   ProcessPacket(InnerConstructResponseHeadersPacket(
       3, stream_id_ + 2, kFin, &spdy_response_header_frame_length));
 
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(OK, promised_stream_->ReadResponseHeaders(callback_.callback()));
+  EXPECT_THAT(promised_stream_->ReadResponseHeaders(callback_.callback()),
+              IsOk());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(404, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
   EXPECT_FALSE(response_.response_time.is_null());
   EXPECT_FALSE(response_.request_time.is_null());
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(
       0, promised_stream_->ReadResponseBody(
              read_buffer_.get(), read_buffer_->size(), callback_.callback()));
@@ skipping 26 matching lines @@
   request_.url = GURL("http://www.example.org/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
                     TestCompletionCallback().callback()));
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
 
   int result = stream_->SendRequest(headers_, &response_, callback_.callback());
-  EXPECT_EQ(ERR_FAILED, result);
+  EXPECT_THAT(result, IsError(ERR_FAILED));
 
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes includes only headers.
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, DataReadErrorAsynchronous) {
@@ skipping 15 matching lines @@
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
 
   int result = stream_->SendRequest(headers_, &response_, callback_.callback());
 
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
   SetResponse("200 OK", string());
 
-  EXPECT_EQ(ERR_IO_PENDING, result);
-  EXPECT_EQ(ERR_FAILED, callback_.GetResult(result));
+  EXPECT_THAT(result, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback_.GetResult(result), IsError(ERR_FAILED));
 
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes includes only headers.
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 }  // namespace test
 }  // namespace net