Create a Perspective enum to use instead of a bool is_server to improve

net/quic/quic_headers_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/quic/quic_headers_stream.h"
 
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
@@ skipping 58 matching lines @@
                               uint32 max_age,
                               uint16 port,
                               StringPiece protocol_id,
                               StringPiece host,
                               StringPiece origin));
   MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type));
 };
 
 // Run all tests with each version, and client or server
 struct TestParams {
-  TestParams(QuicVersion version, bool is_server)
-      : version(version), is_server(is_server) {}
+  TestParams(QuicVersion version, Perspective perspective)
+      : version(version), perspective(perspective) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ version: " << QuicVersionToString(p.version);
-    os << ", is_server: " << p.is_server << " }";
+    os << ", perspective: " << p.perspective << " }";
     return os;
   }
 
   QuicVersion version;
-  bool is_server;
+  Perspective perspective;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
   for (const QuicVersion version : all_supported_versions) {
-    params.push_back(TestParams(version, false));
-    params.push_back(TestParams(version, true));
+    params.push_back(TestParams(version, Perspective::IS_CLIENT));
+    params.push_back(TestParams(version, Perspective::IS_SERVER));
   }
   return params;
 }
 
 class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
  public:
   QuicHeadersStreamTest()
-      : connection_(new StrictMock<MockConnection>(is_server(), GetVersion())),
+      : connection_(
+            new StrictMock<MockConnection>(perspective(), GetVersion())),
         session_(connection_),
         headers_stream_(QuicSessionPeer::GetHeadersStream(&session_)),
         body_("hello world"),
         framer_(version() > QUIC_VERSION_23 ? SPDY4 : SPDY3) {
     headers_[":version"]  = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
     framer_.set_visitor(&visitor_);
     EXPECT_EQ(version(), session_.connection()->version());
     EXPECT_TRUE(headers_stream_ != nullptr);
@@ skipping 73 matching lines @@
   void CheckHeaders() {
     SpdyHeaderBlock headers;
     EXPECT_EQ(saved_header_data_.length(),
               framer_.ParseHeaderBlockInBuffer(saved_header_data_.data(),
                                                saved_header_data_.length(),
                                                &headers));
     EXPECT_EQ(headers_, headers);
     saved_header_data_.clear();
   }
 
-  bool is_server() { return GetParam().is_server; }
+  Perspective perspective() { return GetParam().perspective; }
 
   QuicVersion version() { return GetParam().version; }
 
   QuicVersionVector GetVersion() {
     QuicVersionVector versions;
     versions.push_back(version());
     return versions;
   }
 
   void CloseConnection() {
@@ skipping 26 matching lines @@
 
 TEST_P(QuicHeadersStreamTest, EffectivePriority) {
   EXPECT_EQ(0u, headers_stream_->EffectivePriority());
 }
 
 TEST_P(QuicHeadersStreamTest, WriteHeaders) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (int count = 0; count < 2; ++count) {
       bool fin = (count == 0);
-      if (is_server()) {
+      if (perspective() == Perspective::IS_SERVER) {
         WriteHeadersAndExpectSynReply(stream_id, fin);
       } else {
         for (QuicPriority priority = 0; priority < 7; ++priority) {
           // TODO(rch): implement priorities correctly.
           WriteHeadersAndExpectSynStream(stream_id, fin, 0);
         }
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessRawData) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (int count = 0; count < 2; ++count) {
       bool fin = (count == 0);
       for (QuicPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         scoped_ptr<SpdySerializedFrame> frame;
-        if (is_server()) {
+        if (perspective() == Perspective::IS_SERVER) {
           if (version() > QUIC_VERSION_23) {
             SpdyHeadersIR headers_frame(stream_id);
             headers_frame.set_name_value_block(headers_);
             headers_frame.set_fin(fin);
             headers_frame.set_has_priority(true);
             frame.reset(framer_.SerializeFrame(headers_frame));
           } else {
             SpdySynStreamIR syn_stream(stream_id);
             syn_stream.set_name_value_block(headers_);
             syn_stream.set_fin(fin);
@@ skipping 33 matching lines @@
   headers_["key0"] = string(1 << 13, '.');
   headers_["key1"] = string(1 << 13, '.');
   headers_["key2"] = string(1 << 13, '.');
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (int count = 0; count < 2; ++count) {
       bool fin = (count == 0);
       for (QuicPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         scoped_ptr<SpdySerializedFrame> frame;
-        if (is_server()) {
+        if (perspective() == Perspective::IS_SERVER) {
           if (version() > QUIC_VERSION_23) {
             SpdyHeadersIR headers_frame(stream_id);
             headers_frame.set_name_value_block(headers_);
             headers_frame.set_fin(fin);
             headers_frame.set_has_priority(true);
             frame.reset(framer_.SerializeFrame(headers_frame));
           } else {
             SpdySynStreamIR syn_stream(stream_id);
             syn_stream.set_name_value_block(headers_);
             syn_stream.set_fin(fin);
@@ skipping 125 matching lines @@
 }
 
 TEST_P(QuicHeadersStreamTest, NoConnectionLevelFlowControl) {
   EXPECT_FALSE(ReliableQuicStreamPeer::StreamContributesToConnectionFlowControl(
       headers_stream_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net