Update from https://crrev.com/306655

net/quic/quic_flow_controller.h

Index: net/quic/quic_flow_controller.h
diff --git a/net/quic/quic_flow_controller.h b/net/quic/quic_flow_controller.h
index 0df2b0e7497ce21f2b529392538fe8e423dd751a..371b8c9242b44d0a2bbf7a68909e0f82b12fe085 100644
--- a/net/quic/quic_flow_controller.h
+++ b/net/quic/quic_flow_controller.h
@@ -28,30 +28,30 @@ class NET_EXPORT_PRIVATE QuicFlowController {
   QuicFlowController(QuicConnection* connection,
                      QuicStreamId id,
                      bool is_server,
-                     uint64 send_window_offset,
-                     uint64 receive_window_offset,
-                     uint64 max_receive_window);
+                     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(uint64 new_offset);
+  bool UpdateHighestReceivedOffset(QuicStreamOffset new_offset);
 
   // Called when bytes received from the peer are consumed locally. This may
   // trigger the sending of a WINDOW_UPDATE frame using |connection|.
-  void AddBytesConsumed(uint64 bytes_consumed);
+  void AddBytesConsumed(QuicByteCount bytes_consumed);
 
   // Called when bytes are sent to the peer.
-  void AddBytesSent(uint64 bytes_sent);
+  void AddBytesSent(QuicByteCount bytes_sent);
 
   // Set a new send window offset.
   // Returns true if this increases send_window_offset_ and is now blocked.
-  bool UpdateSendWindowOffset(uint64 new_send_window_offset);
+  bool UpdateSendWindowOffset(QuicStreamOffset new_send_window_offset);
 
   // Returns the current available send window.
-  uint64 SendWindowSize() const;
+  QuicByteCount SendWindowSize() const;
 
   // Send a BLOCKED frame if appropriate.
   void MaybeSendBlocked();
@@ -68,9 +68,9 @@ class NET_EXPORT_PRIVATE QuicFlowController {
   // Returns true if flow control receive limits have been violated by the peer.
   bool FlowControlViolation();
 
-  uint64 bytes_consumed() const { return bytes_consumed_; }
+  QuicByteCount bytes_consumed() const { return bytes_consumed_; }
 
-  uint64 highest_received_byte_offset() const {
+  QuicStreamOffset highest_received_byte_offset() const {
     return highest_received_byte_offset_;
   }
 
@@ -97,29 +97,29 @@ class NET_EXPORT_PRIVATE QuicFlowController {
 
   // Track number of bytes received from the peer, which have been consumed
   // locally.
-  uint64 bytes_consumed_;
+  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.
-  uint64 highest_received_byte_offset_;
+  QuicStreamOffset highest_received_byte_offset_;
 
   // Tracks number of bytes sent to the peer.
-  uint64 bytes_sent_;
+  QuicByteCount bytes_sent_;
 
   // The absolute offset in the outgoing byte stream. If this offset is reached
   // then we become flow control blocked until we receive a WINDOW_UPDATE.
-  uint64 send_window_offset_;
+  QuicStreamOffset send_window_offset_;
 
   // The absolute offset in the incoming byte stream. The peer should never send
   // us bytes which are beyond this offset.
-  uint64 receive_window_offset_;
+  QuicStreamOffset receive_window_offset_;
 
   // Largest size the receive window can grow to.
-  uint64 max_receive_window_;
+  QuicByteCount max_receive_window_;
 
   // 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.
-  uint64 last_blocked_send_window_offset_;
+  QuicStreamOffset last_blocked_send_window_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFlowController);
 };