Set up field trials for SSL read/write buffer sizes.

net/socket/ssl_client_socket_impl.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/socket/ssl_client_socket_impl.h"
 
 #include <errno.h>
 #include <openssl/bio.h>
 #include <openssl/bytestring.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/mem.h>
 #include <openssl/ssl.h>
 #include <string.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "crypto/auto_cbb.h"
@@ skipping 889 matching lines @@
   if (!unused.AssignFromIPLiteral(host_and_port_.host()) &&
       !SSL_set_tlsext_host_name(ssl_, host_and_port_.host().c_str())) {
     return ERR_UNEXPECTED;
   }
 
   ScopedSSL_SESSION session =
       context->session_cache()->Lookup(GetSessionCacheKey());
   if (session)
     SSL_set_session(ssl_, session.get());
 
+  // Get read and write buffer sizes from field trials, if possible. If values
+  // not present, use default.  Also make sure values are in reasonable range.
+  int send_buffer_size;
+  if (!base::StringToInt(
+          base::FieldTrialList::FindFullName("SSLBufferSizeSend"),
+          &send_buffer_size)) {
+    send_buffer_size = KDefaultOpenSSLBufferSize;

[davidben, 2016/06/27 18:31:48]

(Haha. While you're here, do you mind fixing KDefaultOpenSSLBufferSize to be
kDefaultOpenSSLBufferSize?)

[mmenke, 2016/06/27 20:01:06]

I completely missed that!  Done.

+  }
+  send_buffer_size = std::max(send_buffer_size, 1000);
+  send_buffer_size = std::min(send_buffer_size, 2 * KDefaultOpenSSLBufferSize);
   send_buffer_ = new GrowableIOBuffer();
-  send_buffer_->SetCapacity(KDefaultOpenSSLBufferSize);
+  send_buffer_->SetCapacity(send_buffer_size);
+
+  int recv_buffer_size;
+  if (!base::StringToInt(
+          base::FieldTrialList::FindFullName("SSLBufferSizeRecv"),
+          &recv_buffer_size)) {
+    recv_buffer_size = KDefaultOpenSSLBufferSize;
+  }
+  recv_buffer_size = std::max(recv_buffer_size, 1000);
+  recv_buffer_size = std::min(recv_buffer_size, 2 * KDefaultOpenSSLBufferSize);
   recv_buffer_ = new GrowableIOBuffer();
-  recv_buffer_->SetCapacity(KDefaultOpenSSLBufferSize);
+  recv_buffer_->SetCapacity(recv_buffer_size);
 
   BIO* ssl_bio = NULL;
 
   // SSLClientSocketImpl retains ownership of the BIO buffers.
   if (!BIO_new_bio_pair_external_buf(
           &ssl_bio, send_buffer_->capacity(),
           reinterpret_cast<uint8_t*>(send_buffer_->data()), &transport_bio_,
           recv_buffer_->capacity(),
           reinterpret_cast<uint8_t*>(recv_buffer_->data())))
     return ERR_UNEXPECTED;
@@ skipping 1390 matching lines @@
   if (rv != OK) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv);
     return;
   }
 
   net_log_.EndEvent(NetLog::TYPE_SSL_CONNECT,
                     base::Bind(&NetLogSSLInfoCallback, base::Unretained(this)));
 }
 
 }  // namespace net