Enable exporting SSLKEYLOGFILE on Android w/ command line arguments

net/socket/ssl_client_socket_openssl.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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <errno.h>
 #include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/ssl.h>
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
-#include "base/environment.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_local.h"
 #include "base/values.h"
@@ skipping 208 matching lines @@
     // It would be better if the callback were not a global setting,
     // but that is an OpenSSL issue.
     SSL_CTX_set_next_proto_select_cb(ssl_ctx_.get(), SelectNextProtoCallback,
                                      NULL);
 
     // Disable the internal session cache. Session caching is handled
     // externally (i.e. by SSLClientSessionCacheOpenSSL).
     SSL_CTX_set_session_cache_mode(
         ssl_ctx_.get(), SSL_SESS_CACHE_CLIENT | SSL_SESS_CACHE_NO_INTERNAL);
     SSL_CTX_sess_set_new_cb(ssl_ctx_.get(), NewSessionCallback);
-
-    scoped_ptr<base::Environment> env(base::Environment::Create());
-    std::string ssl_keylog_file;
-    if (env->GetVar("SSLKEYLOGFILE", &ssl_keylog_file) &&
-        !ssl_keylog_file.empty()) {
-      crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-      BIO* bio = BIO_new_file(ssl_keylog_file.c_str(), "a");
-      if (!bio) {
-        LOG(ERROR) << "Failed to open " << ssl_keylog_file;
-        ERR_print_errors_cb(&LogErrorCallback, NULL);
-      } else {
-        SSL_CTX_set_keylog_bio(ssl_ctx_.get(), bio);
-      }
-    }
   }
 
   static int ClientCertRequestCallback(SSL* ssl, void* arg) {
     SSLClientSocketOpenSSL* socket = GetInstance()->GetClientSocketFromSSL(ssl);
     DCHECK(socket);
     return socket->ClientCertRequestCallback(ssl);
   }
 
   static int CertVerifyCallback(X509_STORE_CTX *store_ctx, void *arg) {
     SSL* ssl = reinterpret_cast<SSL*>(X509_STORE_CTX_get_ex_data(
@@ skipping 193 matching lines @@
       policy_enforcer_(context.cert_policy_enforcer),
       net_log_(transport_->socket()->NetLog()),
       weak_factory_(this) {
   DCHECK(cert_verifier_);
 }
 
 SSLClientSocketOpenSSL::~SSLClientSocketOpenSSL() {
   Disconnect();
 }
 
+void SSLClientSocketOpenSSL::SetSSLKeyLogFile(
+    const std::string& ssl_keylog_file) {
+  crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
+  BIO* bio = BIO_new_file(ssl_keylog_file.c_str(), "a");
+  if (!bio) {
+    LOG(ERROR) << "Failed to open " << ssl_keylog_file;
+    ERR_print_errors_cb(&LogErrorCallback, NULL);
+  } else {
+    SSL_CTX_set_keylog_bio(SSLContext::GetInstance()->ssl_ctx(), bio);
+  }
+}
+
 void SSLClientSocketOpenSSL::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   cert_request_info->host_and_port = host_and_port_;
   cert_request_info->cert_authorities = cert_authorities_;
   cert_request_info->cert_key_types = cert_key_types_;
 }
 
 SSLClientSocket::NextProtoStatus SSLClientSocketOpenSSL::GetNextProto(
     std::string* proto) const {
   *proto = npn_proto_;
@@ skipping 1682 matching lines @@
     OnHandshakeIOComplete(signature_result_);
     return;
   }
 
   // During a renegotiation, either Read or Write calls may be blocked on an
   // asynchronous private key operation.
   PumpReadWriteEvents();
 }
 
 }  // namespace net