Roll Chrome into Mojo.

net/quic/quic_config.cc

 // Copyright (c) 2013 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_config.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 529 matching lines @@
 
 bool QuicConfig::HasInitialRoundTripTimeUsToSend() const {
   return initial_round_trip_time_us_.HasSendValue();
 }
 
 uint32 QuicConfig::GetInitialRoundTripTimeUsToSend() const {
   return initial_round_trip_time_us_.GetSendValue();
 }
 
 void QuicConfig::SetInitialFlowControlWindowToSend(uint32 window_bytes) {
-  if (window_bytes < kDefaultFlowControlSendWindow) {
+  if (window_bytes < kMinimumFlowControlSendWindow) {
     LOG(DFATAL) << "Initial flow control receive window (" << window_bytes
                 << ") cannot be set lower than default ("
-                << kDefaultFlowControlSendWindow << ").";
-    window_bytes = kDefaultFlowControlSendWindow;
+                << kMinimumFlowControlSendWindow << ").";
+    window_bytes = kMinimumFlowControlSendWindow;
   }
   initial_flow_control_window_bytes_.SetSendValue(window_bytes);
 }
 
 uint32 QuicConfig::GetInitialFlowControlWindowToSend() const {
   return initial_flow_control_window_bytes_.GetSendValue();
 }
 
 bool QuicConfig::HasReceivedInitialFlowControlWindowBytes() const {
   return initial_flow_control_window_bytes_.HasReceivedValue();
 }
 
 uint32 QuicConfig::ReceivedInitialFlowControlWindowBytes() const {
   return initial_flow_control_window_bytes_.GetReceivedValue();
 }
 
 void QuicConfig::SetInitialStreamFlowControlWindowToSend(uint32 window_bytes) {
-  if (window_bytes < kDefaultFlowControlSendWindow) {
+  if (window_bytes < kMinimumFlowControlSendWindow) {
     LOG(DFATAL) << "Initial stream flow control receive window ("
                 << window_bytes << ") cannot be set lower than default ("
-                << kDefaultFlowControlSendWindow << ").";
-    window_bytes = kDefaultFlowControlSendWindow;
+                << kMinimumFlowControlSendWindow << ").";
+    window_bytes = kMinimumFlowControlSendWindow;
   }
   initial_stream_flow_control_window_bytes_.SetSendValue(window_bytes);
 }
 
 uint32 QuicConfig::GetInitialStreamFlowControlWindowToSend() const {
   return initial_stream_flow_control_window_bytes_.GetSendValue();
 }
 
 bool QuicConfig::HasReceivedInitialStreamFlowControlWindowBytes() const {
   return initial_stream_flow_control_window_bytes_.HasReceivedValue();
 }
 
 uint32 QuicConfig::ReceivedInitialStreamFlowControlWindowBytes() const {
   return initial_stream_flow_control_window_bytes_.GetReceivedValue();
 }
 
 void QuicConfig::SetInitialSessionFlowControlWindowToSend(uint32 window_bytes) {
-  if (window_bytes < kDefaultFlowControlSendWindow) {
+  if (window_bytes < kMinimumFlowControlSendWindow) {
     LOG(DFATAL) << "Initial session flow control receive window ("
                 << window_bytes << ") cannot be set lower than default ("
-                << kDefaultFlowControlSendWindow << ").";
-    window_bytes = kDefaultFlowControlSendWindow;
+                << kMinimumFlowControlSendWindow << ").";
+    window_bytes = kMinimumFlowControlSendWindow;
   }
   initial_session_flow_control_window_bytes_.SetSendValue(window_bytes);
 }
 
 uint32 QuicConfig::GetInitialSessionFlowControlWindowToSend() const {
   return initial_session_flow_control_window_bytes_.GetSendValue();
 }
 
 bool QuicConfig::HasReceivedInitialSessionFlowControlWindowBytes() const {
   return initial_session_flow_control_window_bytes_.HasReceivedValue();
@@ skipping 40 matching lines @@
     silent_close_.set(0, 0);
   }
   SetMaxStreamsPerConnection(kDefaultMaxStreamsPerConnection,
                              kDefaultMaxStreamsPerConnection);
   max_time_before_crypto_handshake_ =
       QuicTime::Delta::FromSeconds(kMaxTimeForCryptoHandshakeSecs);
   max_idle_time_before_crypto_handshake_ =
       QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs);
   max_undecryptable_packets_ = kDefaultMaxUndecryptablePackets;
 
-  SetInitialFlowControlWindowToSend(kDefaultFlowControlSendWindow);
-  SetInitialStreamFlowControlWindowToSend(kDefaultFlowControlSendWindow);
-  SetInitialSessionFlowControlWindowToSend(kDefaultFlowControlSendWindow);
+  SetInitialFlowControlWindowToSend(kMinimumFlowControlSendWindow);
+  SetInitialStreamFlowControlWindowToSend(kMinimumFlowControlSendWindow);
+  SetInitialSessionFlowControlWindowToSend(kMinimumFlowControlSendWindow);
 }
 
 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   congestion_feedback_.ToHandshakeMessage(out);
   idle_connection_state_lifetime_seconds_.ToHandshakeMessage(out);
   silent_close_.ToHandshakeMessage(out);
   max_streams_per_connection_.ToHandshakeMessage(out);
   bytes_for_connection_id_.ToHandshakeMessage(out);
   initial_round_trip_time_us_.ToHandshakeMessage(out);
   initial_flow_control_window_bytes_.ToHandshakeMessage(out);
@@ skipping 51 matching lines @@
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = connection_options_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net