Increase QUIC's proposed server Intial CWND to 32 for HTTPS to 30; HTTP to 20

net/quic/quic_stream_factory.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_stream_factory.h"
 
 #include <set>
 
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 38 matching lines @@
 enum CreateSessionFailure {
   CREATION_ERROR_CONNECTING_SOCKET,
   CREATION_ERROR_SETTING_RECEIVE_BUFFER,
   CREATION_ERROR_SETTING_SEND_BUFFER,
   CREATION_ERROR_MAX
 };
 
 // The initial receive window size for both streams and sessions.
 const int32 kInitialReceiveWindowSize = 10 * 1024 * 1024;  // 10MB
 
+// The suggested initial congestion windows for a server to use.
+// TODO: This should be tested and optimized, and even better, suggest a window
+// that corresponds to historical bandwidth and min-RTT.
+// Larger initial congestion windows can, if we don't overshoot, reduce latency
+// by avoiding the RTT needed for slow start to double (and re-double) from a
+// default of 10.
+// We match SPDY's use of 32 when secure (since we'd compete with SPDY).
+const int32 kServerSecureInitialCongestionWindow = 32;
+// Be conservative, and just use double a typical TCP  ICWND for HTTP.
+const int32 kServerInecureInitialCongestionWindow = 20;
+
 void HistogramCreateSessionFailure(enum CreateSessionFailure error) {
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error,
                             CREATION_ERROR_MAX);
 }
 
 bool IsEcdsaSupported() {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
 #endif
@@ skipping 667 matching lines @@
 
   QuicConnection* connection =
       new QuicConnection(connection_id, addr, helper_.get(), writer.get(),
                          false, supported_versions_, kInitialReceiveWindowSize);
   writer->SetConnection(connection);
   connection->options()->max_packet_length = max_packet_length_;
 
   InitializeCachedStateInCryptoConfig(server_id, server_info);
 
   QuicConfig config = config_;
+  config_.SetInitialCongestionWindowToSend(
+      server_id.is_https() ? kServerSecureInitialCongestionWindow
+                           : kServerInecureInitialCongestionWindow);
   if (http_server_properties_) {
     const HttpServerProperties::NetworkStats* stats =
         http_server_properties_->GetServerNetworkStats(
             server_id.host_port_pair());
     if (stats != NULL) {
       config.SetInitialRoundTripTimeUsToSend(stats->srtt.InMicroseconds());
     }
   }
 
   *session = new QuicClientSession(
@@ skipping 66 matching lines @@
   }
 
   HttpServerProperties::NetworkStats network_stats;
   network_stats.srtt = base::TimeDelta::FromMicroseconds(stats.srtt_us);
   network_stats.bandwidth_estimate = stats.estimated_bandwidth;
   http_server_properties_->SetServerNetworkStats(server_id.host_port_pair(),
                                                  network_stats);
 }
 
 }  // namespace net