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

net/quic/quic_framer.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/quic/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 124 matching lines @@
     const QuicWindowUpdateFrame& frame) {
   return true;
 }
 
 bool QuicFramerVisitorInterface::OnBlockedFrame(const QuicBlockedFrame& frame) {
   return true;
 }
 
 QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
                        QuicTime creation_time,
-                       bool is_server)
+                       Perspective perspective)
     : visitor_(nullptr),
       fec_builder_(nullptr),
       entropy_calculator_(nullptr),
       error_(QUIC_NO_ERROR),
       last_sequence_number_(0),
       last_serialized_connection_id_(0),
       supported_versions_(supported_versions),
       decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_latch_(false),
-      is_server_(is_server),
+      perspective_(perspective),
       validate_flags_(true),
       creation_time_(creation_time),
       last_timestamp_(QuicTime::Delta::Zero()) {
   DCHECK(!supported_versions.empty());
   quic_version_ = supported_versions_[0];
   decrypter_.reset(QuicDecrypter::Create(kNULL));
   encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
 }
 
 QuicFramer::~QuicFramer() {}
@@ skipping 357 matching lines @@
     DCHECK_NE("", detailed_error_);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) {
     // The visitor suppresses further processing of the packet.
     reader_.reset(nullptr);
     return true;
   }
 
-  if (is_server_ && public_header.version_flag &&
+  if (perspective_ == Perspective::IS_SERVER && public_header.version_flag &&
       public_header.versions[0] != quic_version_) {
     if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) {
       reader_.reset(nullptr);
       return true;
     }
   }
 
   bool rv;
-  if (!is_server_ && public_header.version_flag) {
+  if (perspective_ == Perspective::IS_CLIENT && public_header.version_flag) {
     rv = ProcessVersionNegotiationPacket(&public_header);
   } else if (public_header.reset_flag) {
     rv = ProcessPublicResetPacket(public_header);
   } else if (packet.length() <= kMaxPacketSize) {
     char buffer[kMaxPacketSize];
     rv = ProcessDataPacket(public_header, packet, buffer, kMaxPacketSize);
   } else {
     scoped_ptr<char[]> large_buffer(new char[packet.length()]);
     rv = ProcessDataPacket(public_header, packet, large_buffer.get(),
                            packet.length());
     LOG_IF(DFATAL, rv) << "QUIC should never successfully process packets "
                        << "larger than kMaxPacketSize. packet size:"
                        << packet.length();
   }
 
   reader_.reset(nullptr);
   return rv;
 }
 
 bool QuicFramer::ProcessVersionNegotiationPacket(
     QuicPacketPublicHeader* public_header) {
-  DCHECK(!is_server_);
+  DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
   // Try reading at least once to raise error if the packet is invalid.
   do {
     QuicTag version;
     if (!reader_->ReadBytes(&version, kQuicVersionSize)) {
       set_detailed_error("Unable to read supported version in negotiation.");
       return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
     }
     public_header->versions.push_back(QuicTagToQuicVersion(version));
   } while (!reader_->IsDoneReading());
 
@@ skipping 161 matching lines @@
         return false;
       }
       if (!writer->WriteUInt64(header.public_header.connection_id)) {
         return false;
       }
       break;
   }
   last_serialized_connection_id_ = header.public_header.connection_id;
 
   if (header.public_header.version_flag) {
-    DCHECK(!is_server_);
+    DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
     writer->WriteUInt32(QuicVersionToQuicTag(quic_version_));
   }
 
   if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
                                   header.packet_sequence_number, writer)) {
     return false;
   }
 
   uint8 private_flags = 0;
   if (header.entropy_flag) {
@@ skipping 145 matching lines @@
       public_header->connection_id = last_serialized_connection_id_;
       break;
   }
 
   public_header->sequence_number_length =
       ReadSequenceNumberLength(
           public_flags >> kPublicHeaderSequenceNumberShift);
 
   // Read the version only if the packet is from the client.
   // version flag from the server means version negotiation packet.
-  if (public_header->version_flag && is_server_) {
+  if (public_header->version_flag && perspective_ == Perspective::IS_SERVER) {
     QuicTag version_tag;
     if (!reader_->ReadUInt32(&version_tag)) {
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
 
     // If the version from the new packet is the same as the version of this
     // framer, then the public flags should be set to something we understand.
     // If not, this raises an error.
     QuicVersion version = QuicTagToQuicVersion(version_tag);
@@ skipping 1290 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(nullptr);
   return false;
 }
 
 }  // namespace net