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

net/quic/quic_session.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_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_headers_stream.h"
 #include "net/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::map;
 using std::max;
 using std::string;
 using std::vector;
 
 namespace net {
 
-#define ENDPOINT (is_server() ? "Server: " : " Client: ")
+#define ENDPOINT \
+  (perspective() == Perspective::IS_SERVER ? "Server: " : " Client: ")
 
 // We want to make sure we delete any closed streams in a safe manner.
 // To avoid deleting a stream in mid-operation, we have a simple shim between
 // us and the stream, so we can delete any streams when we return from
 // processing.
 //
 // We could just override the base methods, but this makes it easier to make
 // sure we don't miss any.
 class VisitorShim : public QuicConnectionVisitorInterface {
  public:
@@ skipping 58 matching lines @@
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.MaxStreamsPerConnection()),
-      next_stream_id_(is_server() ? 2 : 5),
+      next_stream_id_(perspective() == Perspective::IS_SERVER ? 2 : 5),
       write_blocked_streams_(true),
       largest_peer_created_stream_id_(0),
       error_(QUIC_NO_ERROR),
       flow_controller_(new QuicFlowController(
           connection_.get(),
           0,
-          is_server(),
+          perspective(),
           kMinimumFlowControlSendWindow,
           config_.GetInitialSessionFlowControlWindowToSend(),
           config_.GetInitialSessionFlowControlWindowToSend())),
       goaway_received_(false),
       goaway_sent_(false),
       has_pending_handshake_(false) {
 }
 
 void QuicSession::InitializeSession() {
   connection_->set_visitor(visitor_shim_.get());
@@ skipping 332 matching lines @@
 }
 
 bool QuicSession::IsCryptoHandshakeConfirmed() {
   return GetCryptoStream()->handshake_confirmed();
 }
 
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
 
   uint32 max_streams = config_.MaxStreamsPerConnection();
-  if (is_server()) {
+  if (perspective() == Perspective::IS_SERVER) {
     // A server should accept a small number of additional streams beyond the
     // limit sent to the client. This helps avoid early connection termination
     // when FIN/RSTs for old streams are lost or arrive out of order.
     // Use a minimum number of additional streams, or a percentage increase,
     // whichever is larger.
     max_streams =
         max(max_streams + kMaxStreamsMinimumIncrement,
             static_cast<uint32>(max_streams * kMaxStreamsMultiplier));
   }
   set_max_open_streams(max_streams);
@@ skipping 151 matching lines @@
       if (connection()->connected()) {
         LOG(ERROR) << "Trying to get stream: " << stream_id
                    << ", largest peer created stream: "
                    << largest_peer_created_stream_id_
                    << ", max delta: " << kMaxStreamIdDelta;
         connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
       }
       return nullptr;
     }
     if (largest_peer_created_stream_id_ == 0) {
-      if (is_server()) {
+      if (perspective() == Perspective::IS_SERVER) {
         largest_peer_created_stream_id_ = 3;
       } else {
         largest_peer_created_stream_id_ = 1;
       }
     }
     for (QuicStreamId id = largest_peer_created_stream_id_ + 2;
          id < stream_id;
          id += 2) {
       implicitly_created_streams_.insert(id);
     }
@@ skipping 96 matching lines @@
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     if (it->second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net