Plumb SSLKEYLOGFILE from Cronet to net

components/cronet/url_request_context_config.cc

 // Copyright 2014 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 "components/cronet/url_request_context_config.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_server_properties.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
+#include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context_builder.h"
 
 namespace cronet {
 
 namespace {
 
 // TODO(xunjieli): Refactor constants in io_thread.cc.
 const char kQuicFieldTrialName[] = "QUIC";
 const char kQuicConnectionOptions[] = "connection_options";
 const char kQuicStoreServerConfigsInProperties[] =
@@ skipping 14 matching lines @@
 const char kQuicUserAgentId[] = "user_agent_id";
 const char kQuicMigrateSessionsEarly[] = "migrate_sessions_early";
 const char kQuicDisableBidirectionalStreams[] =
     "quic_disable_bidirectional_streams";
 
 // AsyncDNS experiment dictionary name.
 const char kAsyncDnsFieldTrialName[] = "AsyncDNS";
 // Name of boolean to enable AsyncDNS experiment.
 const char kAsyncDnsEnable[] = "enable";
 
+const char kSSLKeyLogFile[] = "ssl_key_log_file";
+
 void ParseAndSetExperimentalOptions(
     const std::string& experimental_options,
     net::URLRequestContextBuilder* context_builder,
-    net::NetLog* net_log) {
+    net::NetLog* net_log,
+    const scoped_refptr<base::SequencedTaskRunner>& file_task_runner) {
   if (experimental_options.empty())
     return;
 
   DVLOG(1) << "Experimental Options:" << experimental_options;
   scoped_ptr<base::Value> options =
       base::JSONReader::Read(experimental_options);
 
   if (!options) {
     DCHECK(false) << "Parsing experimental options failed: "
                   << experimental_options;
@@ skipping 118 matching lines @@
       if (net_log == nullptr) {
         DCHECK(false) << "AsyncDNS experiment requires NetLog.";
       } else {
         scoped_ptr<net::HostResolver> host_resolver(
             net::HostResolver::CreateDefaultResolver(net_log));
         host_resolver->SetDnsClientEnabled(true);
         context_builder->set_host_resolver(std::move(host_resolver));
       }
     }
   }
+
+  std::string ssl_key_log_file_string;
+  if (dict->GetString(kSSLKeyLogFile, &ssl_key_log_file_string)) {
+    DCHECK(file_task_runner);
+    base::FilePath ssl_key_log_file(ssl_key_log_file_string);
+    if (!ssl_key_log_file.empty()) {
+      net::SSLClientSocket::SetSSLKeyLogFile(ssl_key_log_file,
+                                             file_task_runner);

[davidben, 2016/03/25 20:30:45]

Hrm. When can this method get called? It's not safe to call this function after
any SSLClientSockets have been created. I assume Cronet lets you create multiple
URLRequestContexts and such.

(We really should get to finishing the SSLClientContext refactor. Then this
nuisance will be resolved. :-/)

[xunjieli, 2016/03/25 20:45:35]

Acknowledged. Talked to David offline. Assuming clients don't create multiple
CronetEngines, we will be fine. Will wait for refactoring is done to expose this
as a stable API. Added a comment.

+    }
+  }
 }
 
 }  // namespace
 
 URLRequestContextConfig::QuicHint::QuicHint(const std::string& host,
                                             int port,
                                             int alternate_port)
     : host(host), port(port), alternate_port(alternate_port) {}
 
 URLRequestContextConfig::QuicHint::~QuicHint() {}
@@ skipping 37 matching lines @@
       data_reduction_primary_proxy(data_reduction_primary_proxy),
       data_reduction_fallback_proxy(data_reduction_fallback_proxy),
       data_reduction_secure_proxy_check_url(
           data_reduction_secure_proxy_check_url),
       mock_cert_verifier(std::move(mock_cert_verifier)) {}
 
 URLRequestContextConfig::~URLRequestContextConfig() {}
 
 void URLRequestContextConfig::ConfigureURLRequestContextBuilder(
     net::URLRequestContextBuilder* context_builder,
-    net::NetLog* net_log) {
+    net::NetLog* net_log,
+    const scoped_refptr<base::SequencedTaskRunner>& file_task_runner) {
   std::string config_cache;
   if (http_cache != DISABLED) {
     net::URLRequestContextBuilder::HttpCacheParams cache_params;
     if (http_cache == DISK && !storage_path.empty()) {
       cache_params.type = net::URLRequestContextBuilder::HttpCacheParams::DISK;
       cache_params.path = base::FilePath(storage_path);
     } else {
       cache_params.type =
           net::URLRequestContextBuilder::HttpCacheParams::IN_MEMORY;
     }
     cache_params.max_size = http_cache_max_size;
     context_builder->EnableHttpCache(cache_params);
   } else {
     context_builder->DisableHttpCache();
   }
   context_builder->set_user_agent(user_agent);
   context_builder->SetSpdyAndQuicEnabled(enable_spdy, enable_quic);
   context_builder->set_sdch_enabled(enable_sdch);
   if (enable_quic)
     context_builder->set_quic_user_agent_id(quic_user_agent_id);
 
-  ParseAndSetExperimentalOptions(experimental_options, context_builder,
-                                 net_log);
+  ParseAndSetExperimentalOptions(experimental_options, context_builder, net_log,
+                                 file_task_runner);
 
   if (mock_cert_verifier)
     context_builder->SetCertVerifier(std::move(mock_cert_verifier));
   // TODO(mef): Use |config| to set cookies.
 }
 
 }  // namespace cronet