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

net/quic/quic_flow_controller.h

 // Copyright 2014 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_FLOW_CONTROLLER_H_
 #define NET_QUIC_QUIC_FLOW_CONTROLLER_H_
 
 #include "base/basictypes.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_protocol.h"
 
 namespace net {
 
 namespace test {
 class QuicFlowControllerPeer;
 }  // namespace test
 
 class QuicConnection;
 
 const QuicStreamId kConnectionLevelId = 0;
 
 // QuicFlowController allows a QUIC stream or connection to perform flow
 // control. The stream/connection owns a QuicFlowController which keeps track of
 // bytes sent/received, can tell the owner if it is flow control blocked, and
 // can send WINDOW_UPDATE or BLOCKED frames when needed.
 class NET_EXPORT_PRIVATE QuicFlowController {
  public:
   QuicFlowController(QuicConnection* connection,
                      QuicStreamId id,
-                     bool is_server,
+                     Perspective perspective,
                      QuicStreamOffset send_window_offset,
                      QuicStreamOffset receive_window_offset,
                      QuicByteCount max_receive_window);
   ~QuicFlowController() {}
 
   // Called when we see a new highest received byte offset from the peer, either
   // via a data frame or a RST.
   // Returns true if this call changes highest_received_byte_offset_, and false
   // in the case where |new_offset| is <= highest_received_byte_offset_.
   bool UpdateHighestReceivedOffset(QuicStreamOffset new_offset);
@@ skipping 35 matching lines @@
 
   // The parent connection, used to send connection close on flow control
   // violation, and WINDOW_UPDATE and BLOCKED frames when appropriate.
   // Not owned.
   QuicConnection* connection_;
 
   // ID of stream this flow controller belongs to. This can be 0 if this is a
   // connection level flow controller.
   QuicStreamId id_;
 
-  // True if this is owned by a server.
-  bool is_server_;
+  // Tracks if this is owned by a server or a client.
+  Perspective perspective_;
 
   // Track number of bytes received from the peer, which have been consumed
   // locally.
   QuicByteCount bytes_consumed_;
 
   // The highest byte offset we have seen from the peer. This could be the
   // highest offset in a data frame, or a final value in a RST.
   QuicStreamOffset highest_received_byte_offset_;
 
   // Tracks number of bytes sent to the peer.
@@ skipping 13 matching lines @@
   // Keep track of the last time we sent a BLOCKED frame. We should only send
   // another when the number of bytes we have sent has changed.
   QuicStreamOffset last_blocked_send_window_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFlowController);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FLOW_CONTROLLER_H_