TEMP DO NOT LAND

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 <string.h>
 
 #include <utility>
@@ skipping 35 matching lines @@
 #include "net/ssl/ssl_info.h"
 #include "net/ssl/ssl_private_key.h"
 #include "net/ssl/token_binding.h"
 #include "third_party/boringssl/src/include/openssl/bio.h"
 #include "third_party/boringssl/src/include/openssl/bytestring.h"
 #include "third_party/boringssl/src/include/openssl/err.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
 #include "third_party/boringssl/src/include/openssl/mem.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/strings/stringprintf.h"
+
 #if !defined(OS_NACL)
 #include "net/ssl/ssl_key_logger.h"
 #endif
 
 #if defined(USE_NSS_CERTS)
 #include "net/cert_net/nss_ocsp.h"
 #endif
 
 namespace net {
 
@@ skipping 194 matching lines @@
     ssl_ctx_.reset(SSL_CTX_new(SSLv23_client_method()));
     SSL_CTX_set_cert_verify_callback(ssl_ctx_.get(), CertVerifyCallback, NULL);
     SSL_CTX_set_cert_cb(ssl_ctx_.get(), ClientCertRequestCallback, NULL);
     SSL_CTX_set_verify(ssl_ctx_.get(), SSL_VERIFY_PEER, NULL);
 
     // Disable the internal session cache. Session caching is handled
     // externally (i.e. by SSLClientSessionCache).
     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);
-    SSL_CTX_set_timeout(ssl_ctx_.get(), 1 * 60 * 60 /* one hour */);
 
     SSL_CTX_set_grease_enabled(ssl_ctx_.get(), 1);
 
     if (!SSL_CTX_add_client_custom_ext(ssl_ctx_.get(), kTbExtNum,
                                        &TokenBindingAddCallback,
                                        &TokenBindingFreeCallback, nullptr,
                                        &TokenBindingParseCallback, nullptr)) {
       NOTREACHED();
     }
   }
@@ skipping 236 matching lines @@
       signature_result_(kNoPendingResult),
       transport_security_state_(context.transport_security_state),
       policy_enforcer_(context.ct_policy_enforcer),
       pkp_bypassed_(false),
       net_log_(transport_->socket()->NetLog()),
       weak_factory_(this) {
   CHECK(cert_verifier_);
   CHECK(transport_security_state_);
   CHECK(cert_transparency_verifier_);
   CHECK(policy_enforcer_);
+
 }
 
 SSLClientSocketImpl::~SSLClientSocketImpl() {
   Disconnect();
 }
 
 #if !defined(OS_NACL)
 void SSLClientSocketImpl::SetSSLKeyLogFile(
     const base::FilePath& ssl_keylog_file,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 242 matching lines @@
 }
 
 void SSLClientSocketImpl::GetConnectionAttempts(ConnectionAttempts* out) const {
   out->clear();
 }
 
 int64_t SSLClientSocketImpl::GetTotalReceivedBytes() const {
   return transport_->socket()->GetTotalReceivedBytes();
 }
 
+void SSLClientSocketImpl::PopulateAllocatorDump(
+    base::trace_event::MemoryAllocatorDump* dump) const {
+  size_t total_size = 0;
+  base::trace_event::MemoryAllocatorDump* socket_dump =
+      dump->process_memory_dump()->CreateAllocatorDump(base::StringPrintf(
+          "%s/ssl_socket_%p", dump->absolute_name().c_str(), this));
+  if (transport_adapter_) {
+    size_t bio_buffers_size = transport_adapter_->GetEffectiveSize();
+  socket_dump->AddScalar("buffer_size",
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                         bio_buffers_size);
+  total_size+= bio_buffers_size;
+  }
+  size_t total_cert_size = 0;
+  size_t certs_count = 0;
+  if (server_cert_chain_) {
+    certs_count = server_cert_chain_->size();
+    for (size_t i = 0; i < certs_count; ++i) {
+      X509* cert = server_cert_chain_->Get(i);
+      total_cert_size += i2d_X509(cert, nullptr);
+    }
+  }
+  socket_dump->AddScalar("cert_size",
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                         total_cert_size);
+  socket_dump->AddScalar("cert_count",
+                         base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+                         certs_count);
+  // FIXME
+  socket_dump->AddString(
+      "host and port", "",
+      base::StringPrintf("%s:%d", host_and_port_.host().c_str(),
+                         host_and_port_.port()));
+  total_size += total_cert_size;
+  socket_dump->AddScalar(
+      base::trace_event::MemoryAllocatorDump::kNameSize,
+      base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+      total_size);
+}
+
+// static
+void SSLClientSocketImpl::PopulateSSLClientSessionAllocatorDump(
+    base::trace_event::MemoryAllocatorDump* dump) {
+  SSLContext::GetInstance()->session_cache()->PopulateAllocatorDump(dump);
+}
+
 int SSLClientSocketImpl::Read(IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback) {
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
 
   int rv = DoPayloadRead();
 
   if (rv == ERR_IO_PENDING) {
     user_read_callback_ = callback;
@@ skipping 505 matching lines @@
 
 void SSLClientSocketImpl::OnHandshakeIOComplete(int result) {
   int rv = DoHandshakeLoop(result);
   if (rv != ERR_IO_PENDING) {
     LogConnectEndEvent(rv);
     DoConnectCallback(rv);
   }
 }
 
 int SSLClientSocketImpl::DoHandshakeLoop(int last_io_result) {
+  TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION a("net/do_hand_shake");
+
   TRACE_EVENT0("net", "SSLClientSocketImpl::DoHandshakeLoop");
   int rv = last_io_result;
   do {
     // Default to STATE_NONE for next state.
     // (This is a quirk carried over from the windows
     // implementation.  It makes reading the logs a bit harder.)
     // State handlers can and often do call GotoState just
     // to stay in the current state.
     State state = next_handshake_state_;
     next_handshake_state_ = STATE_NONE;
@@ skipping 674 matching lines @@
     if (ERR_GET_REASON(info->error_code) == SSL_R_TLSV1_ALERT_ACCESS_DENIED &&
         !certificate_requested_) {
       net_error = ERR_SSL_PROTOCOL_ERROR;
     }
   }
 
   return net_error;
 }
 
 }  // namespace net