Metric & meta-metric for CECPQ1 handshake latency.

net/socket/ssl_client_socket.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.h"
 
+#include "base/feature_list.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
+#include "build/build_config.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/socket/ssl_client_socket_impl.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/ssl_config_service.h"
 
 namespace net {
 
+namespace {
+#if !defined(OS_NACL)
+const base::Feature kPostQuantumExperiment{"SSLPostQuantumExperiment",

[jwd, 2016/08/01 15:53:53]

We tend not to like features including "experiment" in the name. 

Mostly an FYI, since you already have this deployed, and it would be a hassle to
change.

[mab, 2016/08/09 21:04:41]

OK, leaving alone.  Would you have called it "SSLPostQuantum"?

"Experiment" aims to convey that this will never be enabled for all users, &
that we plan to turn it off in a couple years regardless of outcome.

[jwd, 2016/08/10 17:39:26]

Probably SSLPostQuantum, but I might have gone with SSLPostQuantumExperiment
too, for the reason you describe. Though I think SSLPostQuantum, and a comment
describing the temporaryness of it would be better.

So actually, can you add a comment that this isn't a permanent thing, and should
be removed in the future? ;)

+                                           base::FEATURE_DISABLED_BY_DEFAULT};
+#endif
+
+}  // namespace
+
 SSLClientSocket::SSLClientSocket()
     : signed_cert_timestamps_received_(false),
       stapled_ocsp_response_received_(false),
       negotiation_extension_(kExtensionUnknown) {
 }
 
 // static
 NextProto SSLClientSocket::NextProtoFromString(
     const std::string& proto_string) {
   if (proto_string == "http1.1" || proto_string == "http/1.1") {
@@ skipping 63 matching lines @@
   return NextProtoFromString(proto);
 }
 
 bool SSLClientSocket::IgnoreCertError(int error, int load_flags) {
   if (error == OK)
     return true;
   return (load_flags & LOAD_IGNORE_ALL_CERT_ERRORS) &&
          IsCertificateError(error);
 }
 
+// static
+bool SSLClientSocket::IsPostQuantumExperimentEnabled() {
+#if !defined(OS_NACL)
+  return base::FeatureList::IsEnabled(kPostQuantumExperiment);
+#endif
+  return false;
+}
+
 void SSLClientSocket::RecordNegotiationExtension() {
   if (negotiation_extension_ == kExtensionUnknown)
     return;
   std::string proto;
   SSLClientSocket::NextProtoStatus status = GetNextProto(&proto);
   if (status == kNextProtoUnsupported)
     return;
   // Convert protocol into numerical value for histogram.
   NextProto protocol_negotiated = SSLClientSocket::NextProtoFromString(proto);
   base::HistogramBase::Sample sample =
@@ skipping 65 matching lines @@
     wire_protos.push_back(proto.size());
     for (const char ch : proto) {
       wire_protos.push_back(static_cast<uint8_t>(ch));
     }
   }
 
   return wire_protos;
 }
 
 }  // namespace net