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

net/http/http_stream_parser_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_stream_parser.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 16 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socket_test_util.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 const size_t kOutputSize = 1024;  // Just large enough for this test.
 // The number of bytes that can fit in a buffer of kOutputSize.
 const size_t kMaxPayloadSize =
     kOutputSize - HttpStreamParser::kChunkHeaderFooterSize;
 
 // Helper method to create a connected ClientSocketHandle using |data|.
 // Modifies |data|.
 std::unique_ptr<ClientSocketHandle> CreateConnectedSocketHandle(
     SequencedSocketData* data) {
   data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
 
   std::unique_ptr<MockTCPClientSocket> socket(
       new MockTCPClientSocket(net::AddressList(), nullptr, data));
 
   TestCompletionCallback callback;
-  EXPECT_EQ(OK, socket->Connect(callback.callback()));
+  EXPECT_THAT(socket->Connect(callback.callback()), IsOk());
 
   std::unique_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
   socket_handle->SetSocket(std::move(socket));
   return socket_handle;
 }
 
 class ReadErrorUploadDataStream : public UploadDataStream {
  public:
   enum class FailureMode { SYNC, ASYNC };
 
@@ skipping 30 matching lines @@
       MockWrite(SYNCHRONOUS, 0, "POST / HTTP/1.1\r\n"),
       MockWrite(SYNCHRONOUS, 1, "Content-Length: 12\r\n\r\n"),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::SYNC);
-  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
+              IsOk());
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://localhost");
   request.upload_data_stream = &upload_data_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Content-Length", "12");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   int result = parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
                                   callback.callback());
-  EXPECT_EQ(ERR_FAILED, callback.GetResult(result));
+  EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
 }
 
 TEST(HttpStreamParser, DataReadErrorAsynchronous) {
   MockWrite writes[] = {
       MockWrite(ASYNC, 0, "POST / HTTP/1.1\r\n"),
       MockWrite(ASYNC, 1, "Content-Length: 12\r\n\r\n"),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::ASYNC);
-  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
+              IsOk());
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://localhost");
   request.upload_data_stream = &upload_data_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Content-Length", "12");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   int result = parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
                                   callback.callback());
-  EXPECT_EQ(ERR_IO_PENDING, result);
+  EXPECT_THAT(result, IsError(ERR_IO_PENDING));
 
-  EXPECT_EQ(ERR_FAILED, callback.GetResult(result));
+  EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
 }
 
 // The empty payload is how the last chunk is encoded.
 TEST(HttpStreamParser, EncodeChunk_EmptyPayload) {
   char output[kOutputSize];
 
   const base::StringPiece kPayload = "";
   const base::StringPiece kExpected = "0\r\n\r\n";
   const int num_bytes_written =
@@ skipping 38 matching lines @@
   EXPECT_EQ(kExpected, base::StringPiece(output, num_bytes_written));
 }
 
 TEST(HttpStreamParser, EncodeChunk_TooLargePayload) {
   char output[kOutputSize];
 
   // The payload is one byte larger the output buffer size.
   const std::string kPayload(kMaxPayloadSize + 1, '\xff');
   const int num_bytes_written =
       HttpStreamParser::EncodeChunk(kPayload, output, sizeof(output));
-  ASSERT_EQ(ERR_INVALID_ARGUMENT, num_bytes_written);
+  ASSERT_THAT(num_bytes_written, IsError(ERR_INVALID_ARGUMENT));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_NoBody) {
   // Shouldn't be merged if upload data is non-existent.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", NULL));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   std::unique_ptr<UploadDataStream> body(base::WrapUnique(
       new ElementsUploadDataStream(std::move(element_readers), 0)));
-  ASSERT_EQ(OK, body->Init(CompletionCallback()));
+  ASSERT_THAT(body->Init(CompletionCallback()), IsOk());
   // Shouldn't be merged if upload data is empty.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
   const std::string payload = "123";
   std::unique_ptr<ChunkedUploadDataStream> body(new ChunkedUploadDataStream(0));
   body->AppendData(payload.data(), payload.size(), true);
-  ASSERT_EQ(OK, body->Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(body->Init(TestCompletionCallback().callback()), IsOk());
   // Shouldn't be merged if upload data carries chunked data.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
   // Create an empty temporary file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &temp_file_path));
 
   {
     std::vector<std::unique_ptr<UploadElementReader>> element_readers;
 
     element_readers.push_back(base::WrapUnique(
         new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
                                     temp_file_path, 0, 0, base::Time())));
 
     std::unique_ptr<UploadDataStream> body(
         new ElementsUploadDataStream(std::move(element_readers), 0));
     TestCompletionCallback callback;
-    ASSERT_EQ(ERR_IO_PENDING, body->Init(callback.callback()));
-    ASSERT_EQ(OK, callback.WaitForResult());
+    ASSERT_THAT(body->Init(callback.callback()), IsError(ERR_IO_PENDING));
+    ASSERT_THAT(callback.WaitForResult(), IsOk());
     // Shouldn't be merged if upload data carries a file, as it's not in-memory.
     ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
         "some header", body.get()));
   }
 
   // UploadFileElementReaders may post clean-up tasks on destruction.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_SmallBodyInMemory) {
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   const std::string payload = "123";
   element_readers.push_back(base::WrapUnique(
       new UploadBytesElementReader(payload.data(), payload.size())));
 
   std::unique_ptr<UploadDataStream> body(
       new ElementsUploadDataStream(std::move(element_readers), 0));
-  ASSERT_EQ(OK, body->Init(CompletionCallback()));
+  ASSERT_THAT(body->Init(CompletionCallback()), IsOk());
   // Yes, should be merged if the in-memory body is small here.
   ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_LargeBodyInMemory) {
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   const std::string payload(10000, 'a');  // 'a' x 10000.
   element_readers.push_back(base::WrapUnique(
       new UploadBytesElementReader(payload.data(), payload.size())));
 
   std::unique_ptr<UploadDataStream> body(
       new ElementsUploadDataStream(std::move(element_readers), 0));
-  ASSERT_EQ(OK, body->Init(CompletionCallback()));
+  ASSERT_THAT(body->Init(CompletionCallback()), IsOk());
   // Shouldn't be merged if the in-memory body is large here.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, SentBytesNoHeaders) {
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
   };
 
@@ skipping 121 matching lines @@
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::WrapUnique(new UploadBytesElementReader("hello world!", 12)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
-  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
+              IsOk());
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://localhost");
   request.upload_data_stream = &upload_data_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
                           BoundNetLog());
 
@@ skipping 16 matching lines @@
       MockWrite(ASYNC, 1, "Transfer-Encoding: chunked\r\n\r\n"),
       MockWrite(ASYNC, 2, "7\r\nChunk 1\r\n"),
       MockWrite(SYNCHRONOUS, ERR_FAILED, 3),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   ChunkedUploadDataStream upload_data_stream(0);
-  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
+              IsOk());
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://localhost");
   request.upload_data_stream = &upload_data_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, parser.SendRequest("POST / HTTP/1.1\r\n", headers,
                                                &response, callback.callback()));
 
   base::RunLoop().RunUntilIdle();
   upload_data_stream.AppendData(kChunk, arraysize(kChunk) - 1, false);
 
   base::RunLoop().RunUntilIdle();
   // This write should fail.
   upload_data_stream.AppendData(kChunk, arraysize(kChunk) - 1, false);
-  EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_FAILED));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
 // when sending a request with a chunked body with only one chunk that becomes
 // available asynchronously.
 TEST(HttpStreamParser, AsyncSingleChunkAndAsyncSocket) {
   static const char kChunk[] = "Chunk";
 
@@ skipping 10 matching lines @@
   static const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 4, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 5, "one.html"),
       MockRead(SYNCHRONOUS, 0, 6),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
@@ skipping 11 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
 
   // Complete the initial request write.  Callback should not have been invoked.
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 
   // Now append the only chunk and wait for the callback.
   upload_stream.AppendData(kChunk, arraysize(kChunk) - 1, true);
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Attempt to read the response status and the response headers.
-  ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
@@ skipping 18 matching lines @@
   static const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 4, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 5, "one.html"),
       MockRead(SYNCHRONOUS, 0, 6),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
   // Append the only chunk.
   upload_stream.AppendData(kChunk, arraysize(kChunk) - 1, true);
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Attempt to read the response status and the response headers.
-  ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
@@ skipping 27 matching lines @@
 
   MockRead reads[] = {
     MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 6, "Content-Length: 8\r\n\r\n"),
     MockRead(ASYNC, 7, "one.html"),
     MockRead(SYNCHRONOUS, 0, 8),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   upload_stream.AppendData(kChunk1, arraysize(kChunk1) - 1, false);
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
@@ skipping 20 matching lines @@
   // Now append another chunk.
   upload_stream.AppendData(kChunk2, arraysize(kChunk2) - 1, false);
   ASSERT_FALSE(callback.have_result());
 
   // Add the final chunk, while the write for the second is still pending,
   // which should not confuse the state machine.
   upload_stream.AppendData(kChunk3, arraysize(kChunk3) - 1, true);
   ASSERT_FALSE(callback.have_result());
 
   // Wait for writes to complete.
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Attempt to read the response status and the response headers.
-  ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
@@ skipping 15 matching lines @@
   const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 3, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 4, "one.html"),
       MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
 
   // Now append the terminal 0-byte "chunk".
   upload_stream.AppendData(nullptr, 0, true);
   ASSERT_FALSE(callback.have_result());
 
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Attempt to read the response status and the response headers.
-  ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
@@ skipping 15 matching lines @@
   const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 3, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 4, "one.html"),
       MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
   // Append final empty chunk.
   upload_stream.AppendData(nullptr, 0, true);
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
 
   // Complete writing the request headers and body.
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Attempt to read the response status and the response headers.
-  ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
@@ skipping 74 matching lines @@
       HttpRequestHeaders request_headers;
       HttpResponseInfo response_info;
       TestCompletionCallback callback;
       ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
                                        &response_info, callback.callback()));
 
       int rv = parser.ReadResponseHeaders(callback.callback());
       EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
                 parser.sent_bytes());
       if (i == arraysize(reads) - 1) {
-        EXPECT_EQ(OK, rv);
+        EXPECT_THAT(rv, IsOk());
         EXPECT_TRUE(response_info.headers.get());
         EXPECT_EQ(CountReadBytes(reads[i], 2), parser.received_bytes());
       } else {
         if (protocol == HTTP) {
-          EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
+          EXPECT_THAT(rv, IsError(ERR_CONNECTION_CLOSED));
           EXPECT_TRUE(response_info.headers.get());
           EXPECT_EQ(CountReadBytes(reads[i], 2), parser.received_bytes());
         } else {
-          EXPECT_EQ(ERR_RESPONSE_HEADERS_TRUNCATED, rv);
+          EXPECT_THAT(rv, IsError(ERR_RESPONSE_HEADERS_TRUNCATED));
           EXPECT_FALSE(response_info.headers.get());
           EXPECT_EQ(0, parser.received_bytes());
         }
       }
     }
   }
 }
 
 // Confirm that on 101 response, the headers are parsed but the data that
 // follows remains in the buffer.
@@ skipping 23 matching lines @@
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(
       socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
   HttpRequestHeaders request_headers;
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
                                    &response_info, callback.callback()));
 
-  EXPECT_EQ(OK, parser.ReadResponseHeaders(callback.callback()));
+  EXPECT_THAT(parser.ReadResponseHeaders(callback.callback()), IsOk());
   ASSERT_TRUE(response_info.headers.get());
   EXPECT_EQ(101, response_info.headers->response_code());
   EXPECT_TRUE(response_info.headers->HasHeaderValue("Connection", "Upgrade"));
   EXPECT_TRUE(response_info.headers->HasHeaderValue("Upgrade", "websocket"));
   EXPECT_EQ(read_buffer->capacity(), read_buffer->offset());
   EXPECT_EQ("a fake websocket frame",
             base::StringPiece(read_buffer->StartOfBuffer(),
                               read_buffer->capacity()));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
@@ skipping 40 matching lines @@
     parser_.reset(new HttpStreamParser(
         socket_handle_.get(), &request_info_, read_buffer(), BoundNetLog()));
 
     TestCompletionCallback callback;
     ASSERT_EQ(OK, parser_->SendRequest("GET / HTTP/1.1\r\n", request_headers_,
                                        &response_info_, callback.callback()));
   }
 
   void ReadHeaders() {
     TestCompletionCallback callback;
-    EXPECT_EQ(OK, parser_->ReadResponseHeaders(callback.callback()));
+    EXPECT_THAT(parser_->ReadResponseHeaders(callback.callback()), IsOk());
   }
 
   void ReadBody(int user_buf_len, int* read_lengths) {
     TestCompletionCallback callback;
     scoped_refptr<IOBuffer> buffer = new IOBuffer(user_buf_len);
     int rv;
     int i = 0;
     while (true) {
       rv = parser_->ReadResponseBody(
           buffer.get(), user_buf_len, callback.callback());
@@ skipping 272 matching lines @@
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), request_info.get(),
                           read_buffer.get(), BoundNetLog());
 
   std::unique_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
   std::unique_ptr<HttpResponseInfo> response_info(new HttpResponseInfo());
   TestCompletionCallback callback;
   ASSERT_EQ(OK, parser.SendRequest("GET /foo.html HTTP/1.1\r\n",
             *request_headers, response_info.get(), callback.callback()));
-  ASSERT_EQ(OK, parser.ReadResponseHeaders(callback.callback()));
+  ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()), IsOk());
 
   // If the object that owns the HttpStreamParser is deleted, it takes the
   // objects passed to the HttpStreamParser with it.
   request_info.reset();
   request_headers.reset();
   response_info.reset();
 
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(kBodySize, parser.ReadResponseBody(
       body_buffer.get(), kBodySize, callback.callback()));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
 }
 
 }  // namespace
 
 }  // namespace net