Update from https://crrev.com/306655

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 345 matching lines @@
   }
 
   // How much data we want to write.
   size_t write_length = TotalIovecLength(iov, iov_count);
 
   // A FIN with zero data payload should not be flow control blocked.
   bool fin_with_zero_data = (fin && write_length == 0);
 
   if (flow_controller_.IsEnabled()) {
     // How much data we are allowed to write from flow control.
-    uint64 send_window = flow_controller_.SendWindowSize();
+    QuicByteCount send_window = flow_controller_.SendWindowSize();
     // TODO(rjshade): Remove connection_flow_controller_->IsEnabled() check when
     // removing QUIC_VERSION_19.
     if (stream_contributes_to_connection_flow_control_ &&
         connection_flow_controller_->IsEnabled()) {
       send_window =
           min(send_window, connection_flow_controller_->SendWindowSize());
     }
 
     if (send_window == 0 && !fin_with_zero_data) {
       // Quick return if we can't send anything.
       MaybeSendBlocked();
       return QuicConsumedData(0, false);
     }
 
     if (write_length > send_window) {
       // Don't send the FIN if we aren't going to send all the data.
       fin = false;
 
       // Writing more data would be a violation of flow control.
-      write_length = send_window;
+      write_length = static_cast<size_t>(send_window);
     }
   }
 
   // Fill an IOVector with bytes from the iovec.
   IOVector data;
   data.AppendIovecAtMostBytes(iov, iov_count, write_length);
 
   QuicConsumedData consumed_data = session()->WritevData(
       id(), data, stream_bytes_written_, fin, GetFecProtection(),
       ack_notifier_delegate);
@@ skipping 62 matching lines @@
     DVLOG(1) << ENDPOINT << "Sending RST in OnClose: " << id();
     session_->SendRstStream(id(), QUIC_RST_ACKNOWLEDGEMENT,
                             stream_bytes_written_);
     rst_sent_ = true;
   }
 
   // We are closing the stream and will not process any further incoming bytes.
   // As there may be more bytes in flight and we need to ensure that both
   // endpoints have the same connection level flow control state, mark all
   // unreceived or buffered bytes as consumed.
-  uint64 bytes_to_consume = flow_controller_.highest_received_byte_offset() -
+  QuicByteCount bytes_to_consume =
+      flow_controller_.highest_received_byte_offset() -
       flow_controller_.bytes_consumed();
   AddBytesConsumed(bytes_to_consume);
 }
 
 void ReliableQuicStream::OnWindowUpdateFrame(
     const QuicWindowUpdateFrame& frame) {
   if (!flow_controller_.IsEnabled()) {
     DLOG(DFATAL) << "Flow control not enabled! " << version();
     return;
   }
   if (flow_controller_.UpdateSendWindowOffset(frame.byte_offset)) {
     // We can write again!
     // TODO(rjshade): This does not respect priorities (e.g. multiple
     //                outstanding POSTs are unblocked on arrival of
     //                SHLO with initial window).
     // As long as the connection is not flow control blocked, we can write!
     OnCanWrite();
   }
 }
 
-bool ReliableQuicStream::MaybeIncreaseHighestReceivedOffset(uint64 new_offset) {
+bool ReliableQuicStream::MaybeIncreaseHighestReceivedOffset(
+    QuicStreamOffset new_offset) {
   if (!flow_controller_.IsEnabled()) {
     return false;
   }
   uint64 increment =
       new_offset - flow_controller_.highest_received_byte_offset();
   if (!flow_controller_.UpdateHighestReceivedOffset(new_offset)) {
     return false;
   }
 
   // If |new_offset| increased the stream flow controller's highest received
   // offset, then we need to increase the connection flow controller's value
   // by the incremental difference.
   if (stream_contributes_to_connection_flow_control_) {
     connection_flow_controller_->UpdateHighestReceivedOffset(
         connection_flow_controller_->highest_received_byte_offset() +
         increment);
   }
   return true;
 }
 
-void ReliableQuicStream::AddBytesSent(uint64 bytes) {
+void ReliableQuicStream::AddBytesSent(QuicByteCount bytes) {
   if (flow_controller_.IsEnabled()) {
     flow_controller_.AddBytesSent(bytes);
     if (stream_contributes_to_connection_flow_control_) {
       connection_flow_controller_->AddBytesSent(bytes);
     }
   }
 }
 
-void ReliableQuicStream::AddBytesConsumed(uint64 bytes) {
+void ReliableQuicStream::AddBytesConsumed(QuicByteCount bytes) {
   if (flow_controller_.IsEnabled()) {
     // Only adjust stream level flow controller if we are still reading.
     if (!read_side_closed_) {
       flow_controller_.AddBytesConsumed(bytes);
     }
 
     if (stream_contributes_to_connection_flow_control_) {
       connection_flow_controller_->AddBytesConsumed(bytes);
     }
   }
 }
 
-void ReliableQuicStream::UpdateSendWindowOffset(uint64 new_window) {
+void ReliableQuicStream::UpdateSendWindowOffset(QuicStreamOffset new_window) {
   if (flow_controller_.UpdateSendWindowOffset(new_window)) {
     OnCanWrite();
   }
 }
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   if (flow_controller_.IsBlocked()) {
     return true;
   }
   return stream_contributes_to_connection_flow_control_ &&
       connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net