Remove the is_server argument from the QuicSession constructor.

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/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::vector;
 
 namespace net {
 
 const size_t kMaxPrematurelyClosedStreamsTracked = 20;
 const size_t kMaxZombieStreams = 20;
 
-#define ENDPOINT (is_server_ ? "Server: " : " Client: ")
+#define ENDPOINT (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 37 matching lines @@
 
   virtual bool HasPendingHandshake() const OVERRIDE {
     return session_->HasPendingHandshake();
   }
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection,
-                         const QuicConfig& config,
-                         bool is_server)
+                         const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.max_streams_per_connection()),
-      next_stream_id_(is_server ? 2 : 3),
-      is_server_(is_server),
+      next_stream_id_(is_server() ? 2 : 3),
       largest_peer_created_stream_id_(0),
       error_(QUIC_NO_ERROR),
       goaway_received_(false),
       goaway_sent_(false),
       has_pending_handshake_(false) {
 
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetFromConfig(config_);
   if (connection_->connected()) {
     connection_->SetOverallConnectionTimeout(
@@ skipping 187 matching lines @@
   if (it == stream_map_.end()) {
     DVLOG(1) << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
   QuicDataStream* stream = it->second;
   if (connection_->connected() && !stream->headers_decompressed()) {
     // If the stream is being closed locally (for example a client cancelling
     // a request before receiving the response) then we need to make sure that
     // we keep the stream alive long enough to process any response or
     // RST_STREAM frames.
-    if (locally_reset && !is_server_) {
+    if (locally_reset && !is_server()) {
       AddZombieStream(stream_id);
       return;
     }
 
     // This stream has been closed before the headers were decompressed.
     // This might cause problems with head of line blocking of headers.
     // If the peer sent headers which were lost but we now close the stream
     // we will never be able to decompress headers for other streams.
     // To deal with this, we keep track of streams which have been closed
     // prematurely.  If we ever receive data frames for this steam, then we
@@ skipping 225 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net