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

net/websockets/websocket_deflate_stream_test.cc

 // Copyright 2013 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/websockets/websocket_deflate_stream.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "net/test/gtest_util.h"
 #include "net/websockets/websocket_deflate_parameters.h"
 #include "net/websockets/websocket_deflate_predictor.h"
 #include "net/websockets/websocket_deflater.h"
 #include "net/websockets/websocket_frame.h"
 #include "net/websockets/websocket_inflater.h"
 #include "net/websockets/websocket_stream.h"
 #include "net/websockets/websocket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 namespace {
 
 typedef ::testing::MockFunction<void(int)> MockCallback;  // NOLINT
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::Return;
 
 typedef uint32_t FrameFlag;
@@ skipping 318 matching lines @@
 };
 
 TEST_F(WebSocketDeflateStreamTest, ReadFailedImmediately) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   CompletionCallback callback;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Return(ERR_FAILED));
   }
-  EXPECT_EQ(ERR_FAILED, deflate_stream_->ReadFrames(&frames, callback));
+  EXPECT_THAT(deflate_stream_->ReadFrames(&frames, callback),
+              IsError(ERR_FAILED));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedFrameImmediately) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal,
            "hello");
   ReadFramesStub stub(OK, &frames_to_output);
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   CompletionCallback callback;
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedFrameAsync) {
   ReadFramesStub stub(ERR_IO_PENDING);
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   MockCallback mock_callback, checkpoint;
   CompletionCallback callback =
       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
-  ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback),
+              IsError(ERR_IO_PENDING));
   ASSERT_EQ(0u, frames.size());
 
   checkpoint.Call(0);
 
   AppendTo(stub.frames_passed(),
            WebSocketFrameHeader::kOpCodeText,
            kFinal,
            "hello");
   stub.callback().Run(OK);
   ASSERT_EQ(1u, frames.size());
@@ skipping 10 matching lines @@
   CompletionCallback callback =
       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(ERR_FAILED));
   }
-  ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback),
+              IsError(ERR_IO_PENDING));
   ASSERT_EQ(0u, frames.size());
 
   checkpoint.Call(0);
 
   AppendTo(stub.frames_passed(),
            WebSocketFrameHeader::kOpCodeText,
            kFinal,
            "hello");
   stub.callback().Run(ERR_FAILED);
   ASSERT_EQ(0u, frames.size());
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadCompressedFrameImmediately) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal | kReserved1,
            std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7));
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadCompressedFrameAsync) {
   ReadFramesStub stub(ERR_IO_PENDING);
   MockCallback mock_callback, checkpoint;
   CompletionCallback callback =
       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
-  ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback),
+              IsError(ERR_IO_PENDING));
 
   checkpoint.Call(0);
 
   AppendTo(stub.frames_passed(),
            WebSocketFrameHeader::kOpCodeText,
            kFinal | kReserved1,
            std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7));
   stub.callback().Run(OK);
 
   ASSERT_EQ(1u, frames.size());
@@ skipping 19 matching lines @@
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub1, &ReadFramesStub::Call))
         .WillOnce(Invoke(&stub2, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
-  ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback),
+              IsError(ERR_IO_PENDING));
   ASSERT_EQ(0u, frames.size());
 
   AppendTo(stub2.frames_passed(),
            WebSocketFrameHeader::kOpCodeText,
            kFinal,
            data2);
 
   checkpoint.Call(0);
   stub2.callback().Run(OK);
 
@@ skipping 39 matching lines @@
            data2);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedEmptyFrames) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kNoFlag);
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeContinuation,
            kFinal);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_FALSE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("", ToString(frames[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
             frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("", ToString(frames[1]));
@@ skipping 10 matching lines @@
            kFinal);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest,
        ReadCompressedFrameFollowedByEmptyFrame) {
   const std::string data("\xf2\x48\xcd\xc9\xc9\x07\x00", 7);
   std::vector<std::unique_ptr<WebSocketFrame>> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kReserved1,
            data);
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeContinuation,
            kFinal);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadControlFrameBetweenDataFrames) {
   const std::string data1("\xf2\x48\xcd", 3);
   const std::string data2("\xc9\xc9\x07\x00", 4);
   std::vector<std::unique_ptr<WebSocketFrame>> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kReserved1,
            data1);
   AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodePing, kFinal);
   AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodeText, kFinal, data2);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodePing, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[1]));
 }
 
@@ skipping 13 matching lines @@
 
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
 
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(3u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeBinary, frames[0]->header.opcode);
   EXPECT_FALSE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[0]->header.payload_length));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
             frames[1]->header.opcode);
   EXPECT_FALSE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[1]->header.payload_length));
@@ skipping 25 matching lines @@
 
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
 
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeBinary, frames[0]->header.opcode);
   EXPECT_FALSE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[0]->header.payload_length));
 
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
             frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
@@ skipping 64 matching lines @@
            std::string("\x4a\x86\x33\x8d\x00\x00", 6));
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("compressed1", ToString(frames[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("compressed2", ToString(frames[1]));
 }
@@ skipping 10 matching lines @@
            "uncompressed2");
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("uncompressed1", ToString(frames[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("uncompressed2", ToString(frames[1]));
 }
@@ skipping 12 matching lines @@
            "uncompressed");
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("compressed", ToString(frames[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("uncompressed", ToString(frames[1]));
 }
@@ skipping 12 matching lines @@
                "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback), IsOk());
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("uncompressed", ToString(frames[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("compressed", ToString(frames[1]));
 }
@@ skipping 12 matching lines @@
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(stub_vector[0].get(), &ReadFramesStub::Call));
 
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(stub_vector[1].get(), &ReadFramesStub::Call));
 
     EXPECT_CALL(mock_callback, Call(OK));
   }
 
-  ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->ReadFrames(&frames, callback),
+              IsError(ERR_IO_PENDING));
   AppendTo(stub_vector[0]->frames_passed(),
            WebSocketFrameHeader::kOpCodeText,
            kReserved1,
            std::string());
   stub_vector[0]->callback().Run(OK);
   AppendTo(stub_vector[1]->frames_passed(),
            WebSocketFrameHeader::kOpCodeContinuation,
            kFinal,
            std::string("\x02\x00"));
   stub_vector[1]->callback().Run(OK);
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_EQ("", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteEmpty) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   CompletionCallback callback;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _)).Times(0);
   }
-  EXPECT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  EXPECT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteFailedImmediately) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   CompletionCallback callback;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Return(ERR_FAILED));
   }
 
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "hello");
   predictor_->AddFramesToBeInput(frames);
-  EXPECT_EQ(ERR_FAILED, deflate_stream_->WriteFrames(&frames, callback));
+  EXPECT_THAT(deflate_stream_->WriteFrames(&frames, callback),
+              IsError(ERR_FAILED));
   predictor_->Clear();
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteFrameImmediately) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   CompletionCallback callback;
   WriteFramesStub stub(predictor_, OK);
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   predictor_->AddFramesToBeInput(frames);
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteFrameAsync) {
   WriteFramesStub stub(predictor_, ERR_IO_PENDING);
   MockCallback mock_callback, checkpoint;
   CompletionCallback callback =
       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   predictor_->AddFramesToBeInput(frames);
-  ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback),
+              IsError(ERR_IO_PENDING));
 
   checkpoint.Call(0);
   stub.callback().Run(OK);
 
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteControlFrameBetweenDataFrames) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "Hel");
   AppendTo(&frames, WebSocketFrameHeader::kOpCodePing, kFinal);
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "lo");
   predictor_->AddFramesToBeInput(frames);
   WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodePing, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_FALSE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
   EXPECT_TRUE(frames_passed[1]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[1]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteEmptyMessage) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal);
   predictor_->AddFramesToBeInput(frames);
   WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\x00", 1), ToString(frames_passed[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteUncompressedMessage) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "AAAA");
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "AAA");
   predictor_->AddFramesToBeInput(frames);
   WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   predictor_->set_result(WebSocketDeflatePredictor::DO_NOT_DEFLATE);
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_FALSE(frames_passed[0]->header.final);
   EXPECT_FALSE(frames_passed[0]->header.reserved1);
   EXPECT_EQ("AAAA", ToString(frames_passed[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
             frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
@@ skipping 19 matching lines @@
   while (true) {
     bool is_final = (total_compressed_frames.size() >= 2);
     std::vector<std::unique_ptr<WebSocketFrame>> frames;
     std::string data;
     for (size_t i = 0; i < size; ++i)
       data += static_cast<char>(lcg.Generate());
     deflater.AddBytes(data.data(), data.size());
     FrameFlag flag = is_final ? kFinal : kNoFlag;
     AppendTo(&frames, WebSocketFrameHeader::kOpCodeBinary, flag, data);
     predictor_->AddFramesToBeInput(frames);
-    ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+    ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
     total_compressed_frames.insert(
         total_compressed_frames.end(),
         std::make_move_iterator(stub.frames()->begin()),
         std::make_move_iterator(stub.frames()->end()));
     stub.frames()->clear();
     if (is_final)
       break;
   }
   deflater.Finish();
   std::string total_deflated;
@@ skipping 23 matching lines @@
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   predictor_->AddFramesToBeInput(frames);
   WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
   EXPECT_TRUE(frames_passed[1]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x00\x11\x00\x00", 5), ToString(frames_passed[1]));
 }
 
 TEST_F(WebSocketDeflateStreamWithDoNotTakeOverContextTest,
        WriteMultipleMessages) {
   std::vector<std::unique_ptr<WebSocketFrame>> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   predictor_->AddFramesToBeInput(frames);
   WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
@@ skipping 16 matching lines @@
   predictor_->AddFramesToBeInput(frames);
   WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
   predictor_->set_result(WebSocketDeflatePredictor::TRY_DEFLATE);
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(5u, frames_passed.size());
 
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_FALSE(frames_passed[0]->header.final);
   EXPECT_FALSE(frames_passed[0]->header.reserved1);
   EXPECT_EQ("He", ToString(frames_passed[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
             frames_passed[1]->header.opcode);
@@ skipping 22 matching lines @@
 TEST_F(WebSocketDeflateStreamWithClientWindowBitsTest, WindowBits8) {
   SetUpWithWindowBits(8);
   CompletionCallback callback;
   AddCompressibleFrameString();
   WriteFramesStub stub(predictor_, OK);
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames_, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames_, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x39\xa3"
                         "(?7\xb3\x34\x17\x00", 21),
             ToString(frames_passed[0]));
 }
 
 // The same input with window_bits=10 returns smaller output.
 TEST_F(WebSocketDeflateStreamWithClientWindowBitsTest, WindowBits10) {
   SetUpWithWindowBits(10);
   CompletionCallback callback;
   AddCompressibleFrameString();
   WriteFramesStub stub(predictor_, OK);
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
-  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames_, callback));
+  ASSERT_THAT(deflate_stream_->WriteFrames(&frames_, callback), IsOk());
   const std::vector<std::unique_ptr<WebSocketFrame>>& frames_passed =
       *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(
       std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x19\x1a\x0e\0\0", 17),
       ToString(frames_passed[0]));
 }
 
 }  // namespace
 
 }  // namespace net