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

net/quic/test_tools/quic_test_utils.h

 // 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.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/congestion_control/loss_detection_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_client_session_base.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_dispatcher.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_per_connection_packet_writer.h"
+#include "net/quic/quic_protocol.h"
 #include "net/quic/quic_sent_packet_manager.h"
 #include "net/quic/quic_session.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/spdy/spdy_framer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace net {
 
 namespace test {
@@ skipping 250 matching lines @@
 
   QuicPacketWriter* Create(QuicConnection* /*connection*/) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NiceMockPacketWriterFactory);
 };
 
 class MockConnection : public QuicConnection {
  public:
   // Uses a MockHelper, ConnectionId of 42, and 127.0.0.1:123.
-  explicit MockConnection(bool is_server);
+  explicit MockConnection(Perspective perspective);
 
   // Uses a MockHelper, ConnectionId of 42, and 127.0.0.1:123.
-  MockConnection(bool is_server, bool is_secure);
+  MockConnection(Perspective perspective, bool is_secure);
 
   // Uses a MockHelper, ConnectionId of 42.
-  MockConnection(IPEndPoint address, bool is_server);
+  MockConnection(IPEndPoint address, Perspective perspective);
 
   // Uses a MockHelper, and 127.0.0.1:123
-  MockConnection(QuicConnectionId connection_id, bool is_server);
+  MockConnection(QuicConnectionId connection_id, Perspective perspective);
 
   // Uses a Mock helper, ConnectionId of 42, and 127.0.0.1:123.
-  MockConnection(bool is_server, const QuicVersionVector& supported_versions);
+  MockConnection(Perspective perspective,
+                 const QuicVersionVector& supported_versions);
 
   ~MockConnection() override;
 
   // If the constructor that uses a MockHelper has been used then this method
   // will advance the time of the MockClock.
   void AdvanceTime(QuicTime::Delta delta);
 
   MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet));
@@ skipping 27 matching lines @@
   }
 
  private:
   scoped_ptr<QuicConnectionHelperInterface> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class PacketSavingConnection : public MockConnection {
  public:
-  explicit PacketSavingConnection(bool is_server);
+  explicit PacketSavingConnection(Perspective perspective);
 
-  PacketSavingConnection(bool is_server,
+  PacketSavingConnection(Perspective perspective,
                          const QuicVersionVector& supported_versions);
 
   ~PacketSavingConnection() override;
 
   void SendOrQueuePacket(QueuedPacket packet) override;
 
   std::vector<QuicEncryptedPacket*> encrypted_packets_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PacketSavingConnection);
@@ skipping 91 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockPacketWriter);
 };
 
 class MockSendAlgorithm : public SendAlgorithmInterface {
  public:
   MockSendAlgorithm();
   ~MockSendAlgorithm() override;
 
-  MOCK_METHOD3(SetFromConfig, void(const QuicConfig& config,
-                                   bool is_server,
-                                   bool using_pacing));
+  MOCK_METHOD3(SetFromConfig,
+               void(const QuicConfig& config,
+                    Perspective perspective,
+                    bool using_pacing));
   MOCK_METHOD1(SetNumEmulatedConnections, void(int num_connections));
   MOCK_METHOD1(SetMaxPacketSize, void(QuicByteCount max_packet_size));
   MOCK_METHOD4(OnCongestionEvent, void(bool rtt_updated,
                                        QuicByteCount bytes_in_flight,
                                        const CongestionVector& acked_packets,
                                        const CongestionVector& lost_packets));
   MOCK_METHOD5(OnPacketSent,
                bool(QuicTime, QuicByteCount, QuicPacketSequenceNumber,
                     QuicByteCount, HasRetransmittableData));
   MOCK_METHOD1(OnRetransmissionTimeout, void(bool));
@@ skipping 127 matching lines @@
   // clears the pointer to it to prevent use-after-free.
   void Unregister(PerConnectionPacketWriter* writer);
 
   PerConnectionPacketWriter* current_writer_;
 };
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_