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

net/quic/quic_framer.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.
 
 #ifndef NET_QUIC_QUIC_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 49 matching lines @@
 
 // This class receives callbacks from the framer when packets
 // are processed.
 class NET_EXPORT_PRIVATE QuicFramerVisitorInterface {
  public:
   virtual ~QuicFramerVisitorInterface() {}
 
   // Called if an error is detected in the QUIC protocol.
   virtual void OnError(QuicFramer* framer) = 0;
 
-  // Called only when |is_server_| is true and the the framer gets a packet with
-  // version flag true and the version on the packet doesn't match
+  // Called only when |perspective_| is IS_SERVER and the the framer gets a
+  // packet with version flag true and the version on the packet doesn't match
   // |quic_version_|. The visitor should return true after it updates the
   // version of the |framer_| to |received_version| or false to stop processing
   // this packet.
   virtual bool OnProtocolVersionMismatch(QuicVersion received_version) = 0;
 
   // Called when a new packet has been received, before it
   // has been validated or processed.
   virtual void OnPacket() = 0;
 
   // Called when a public reset packet has been parsed but has not yet
   // been validated.
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) = 0;
 
-  // Called only when |is_server_| is false and a version negotiation packet has
-  // been parsed.
+  // Called only when |perspective_| is IS_CLIENT and a version negotiation
+  // packet has been parsed.
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) = 0;
 
   // Called when a lost packet has been recovered via FEC,
   // before it has been processed.
   virtual void OnRevivedPacket() = 0;
 
   // Called when the public header has been parsed, but has not been
   // authenticated. If it returns false, framing for this packet will cease.
   virtual bool OnUnauthenticatedPublicHeader(
@@ skipping 82 matching lines @@
 // It also has a QuicFecBuilder that is called when packets are constructed
 // in order to generate FEC data for subsequently building FEC packets.
 class NET_EXPORT_PRIVATE QuicFramer {
  public:
   // Constructs a new framer that installs a kNULL QuicEncrypter and
   // QuicDecrypter for level ENCRYPTION_NONE. |supported_versions| specifies the
   // list of supported QUIC versions. |quic_version_| is set to the maximum
   // version in |supported_versions|.
   QuicFramer(const QuicVersionVector& supported_versions,
              QuicTime creation_time,
-             bool is_server);
+             Perspective perspective);
 
   virtual ~QuicFramer();
 
   // Returns true if |version| is a supported protocol version.
   bool IsSupportedVersion(const QuicVersion version) const;
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
@@ skipping 162 matching lines @@
   static QuicSequenceNumberLength GetMinSequenceNumberLength(
       QuicPacketSequenceNumber sequence_number);
 
   void SetSupportedVersions(const QuicVersionVector& versions) {
     supported_versions_ = versions;
     quic_version_ = versions[0];
   }
 
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
-  bool is_server() const { return is_server_; }
+  Perspective perspective() const { return perspective_; }
 
   static QuicPacketEntropyHash GetPacketEntropyHash(
       const QuicPacketHeader& header);
 
  private:
   friend class test::QuicFramerPeer;
 
   typedef std::map<QuicPacketSequenceNumber, uint8> NackRangeMap;
 
   struct AckFrameInfo {
@@ skipping 138 matching lines @@
   // The encryption level of |alternative_decrypter_|.
   EncryptionLevel alternative_decrypter_level_;
   // |alternative_decrypter_latch_| is true if, when |alternative_decrypter_|
   // successfully decrypts a packet, we should install it as the only
   // decrypter.
   bool alternative_decrypter_latch_;
   // Encrypters used to encrypt packets via EncryptPacket().
   scoped_ptr<QuicEncrypter> encrypter_[NUM_ENCRYPTION_LEVELS];
   // Tracks if the framer is being used by the entity that received the
   // connection or the entity that initiated it.
-  bool is_server_;
+  Perspective perspective_;
   // If false, skip validation that the public flags are set to legal values.
   bool validate_flags_;
   // The time this framer was created.  Time written to the wire will be
   // written as a delta from this value.
   QuicTime creation_time_;
   // The time delta computed for the last timestamp frame. This is relative to
   // the creation_time.
   QuicTime::Delta last_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_