Set receive buffer size, and comment about possible setting of send buffer.

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/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/single_request_host_resolver.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_client_session.h"
@@ skipping 348 matching lines @@
     const AddressList& address_list,
     const BoundNetLog& net_log) {
   QuicGuid guid = random_generator_->RandUint64();
   IPEndPoint addr = *address_list.begin();
   DatagramClientSocket* socket =
       client_socket_factory_->CreateDatagramClientSocket(
           DatagramSocket::DEFAULT_BIND, base::Bind(&base::RandInt),
           net_log.net_log(), net_log.source());
   socket->Connect(addr);
 
+  // We should adaptively set this buffer size, but for now, we'll use a size
+  // that is more than large enough for a 100 packet congestion window, and yet
+  // does not consume "too much" memory.  If we see bursty packet loss, we may
+  // revisit this setting and test for its impact.
+  const int32 kSocketBufferSize(kMaxPacketSize * 100);  // Support 100 packets.
+  socket->SetReceiveBufferSize(kSocketBufferSize);
+  // TODO(jar): What should the UDP send buffer be set to?  If the send buffer
+  // is too large, then we might(?) wastefully queue packets in the OS, when
+  // we'd rather construct packets just in time. We do however expect that the
+  // calculated send rate (paced, or ack clocked), will be well below the egress
+  // rate of the local machine, so that *shouldn't* be a problem.
+  // If the buffer setting is too small, then we will starve our outgoing link
+  // on a fast connection, because we won't respond fast enough to the many
+  // async callbacks to get data from us.  On the other hand, until we have real
+  // pacing support (beyond ack-clocked pacing), we get a bit of adhoc-pacing by
+  // requiring the application to refill this OS buffer (ensuring that we don't
+  // blast a pile of packets at the kernel's max egress rate).
+  // socket->SetSendBufferSize(????);
+
   QuicConnectionHelper* helper = new QuicConnectionHelper(
       base::MessageLoop::current()->message_loop_proxy().get(),
       clock_.get(),
       random_generator_,
       socket);
 
   QuicConnection* connection = new QuicConnection(guid, addr, helper, false);
 
   QuicCryptoClientConfig* crypto_config =
       GetOrCreateCryptoConfig(host_port_proxy_pair);
@@ skipping 29 matching lines @@
     DCHECK(crypto_config);
   } else {
     crypto_config = new QuicCryptoClientConfig();
     crypto_config->SetDefaults();
     all_crypto_configs_[host_port_proxy_pair] = crypto_config;
   }
   return crypto_config;
 }
 
 }  // namespace net