Clean up type usage and fix MSVC "truncated value" warnings in net/quic/.

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"
@@ skipping 419 matching lines @@
 void QuicSession::UpdateFlowControlOnFinalReceivedByteOffset(
     QuicStreamId stream_id, QuicStreamOffset final_byte_offset) {
   map<QuicStreamId, QuicStreamOffset>::iterator it =
       locally_closed_streams_highest_offset_.find(stream_id);
   if (it == locally_closed_streams_highest_offset_.end()) {
     return;
   }
 
   DVLOG(1) << ENDPOINT << "Received final byte offset " << final_byte_offset
            << " for stream " << stream_id;
-  uint64 offset_diff = final_byte_offset - it->second;
+  QuicByteCount offset_diff = final_byte_offset - it->second;
   if (flow_controller_->UpdateHighestReceivedOffset(
       flow_controller_->highest_received_byte_offset() + offset_diff)) {
     // If the final offset violates flow control, close the connection now.
     if (flow_controller_->FlowControlViolation()) {
       connection_->SendConnectionClose(
           QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA);
       return;
     }
   }
 
@@ skipping 25 matching lines @@
             static_cast<uint32>(max_streams * kMaxStreamsMultiplier));
   }
   set_max_open_streams(max_streams);
 
   if (version == QUIC_VERSION_19) {
     // QUIC_VERSION_19 doesn't support independent stream/session flow
     // control windows.
     if (config_.HasReceivedInitialFlowControlWindowBytes()) {
       // Streams which were created before the SHLO was received (0-RTT
       // requests) are now informed of the peer's initial flow control window.
-      uint32 new_window = config_.ReceivedInitialFlowControlWindowBytes();
+      QuicStreamOffset new_window =
+          config_.ReceivedInitialFlowControlWindowBytes();
       OnNewStreamFlowControlWindow(new_window);
       OnNewSessionFlowControlWindow(new_window);
     }
 
     return;
   }
 
   // QUIC_VERSION_21 and higher can have independent stream and session flow
   // control windows.
   if (config_.HasReceivedInitialStreamFlowControlWindowBytes()) {
     // Streams which were created before the SHLO was received (0-RTT
     // requests) are now informed of the peer's initial flow control window.
     OnNewStreamFlowControlWindow(
         config_.ReceivedInitialStreamFlowControlWindowBytes());
   }
   if (config_.HasReceivedInitialSessionFlowControlWindowBytes()) {
     OnNewSessionFlowControlWindow(
         config_.ReceivedInitialSessionFlowControlWindowBytes());
   }
 }
 
-void QuicSession::OnNewStreamFlowControlWindow(uint32 new_window) {
+void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kDefaultFlowControlSendWindow) {
     LOG(ERROR)
         << "Peer sent us an invalid stream flow control send window: "
         << new_window << ", below default: " << kDefaultFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
     }
     return;
   }
 
   // Inform all existing streams about the new window.
   if (connection_->version() >= QUIC_VERSION_21) {
     GetCryptoStream()->UpdateSendWindowOffset(new_window);
     headers_stream_->UpdateSendWindowOffset(new_window);
   }
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     it->second->UpdateSendWindowOffset(new_window);
   }
 }
 
-void QuicSession::OnNewSessionFlowControlWindow(uint32 new_window) {
+void QuicSession::OnNewSessionFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kDefaultFlowControlSendWindow) {
     LOG(ERROR)
         << "Peer sent us an invalid session flow control send window: "
         << new_window << ", below default: " << kDefaultFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
     }
     return;
   }
 
@@ skipping 234 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