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 <openssl/bio.h>
 #include <openssl/bytestring.h>
 #include <openssl/err.h>
@@ skipping 35 matching lines @@
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_parameters_callback.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_client_session_cache.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_info.h"
 #include "net/ssl/ssl_private_key.h"
 #include "net/ssl/token_binding.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 427 matching lines @@
       disconnected_(false),
       negotiated_protocol_(kProtoUnknown),
       channel_id_sent_(false),
       certificate_verified_(false),
       certificate_requested_(false),
       signature_result_(kNoPendingResult),
       transport_security_state_(context.transport_security_state),
       policy_enforcer_(context.ct_policy_enforcer),
       pkp_bypassed_(false),
       net_log_(transport_->socket()->NetLog()),
+      in_pool_(false),
       weak_factory_(this) {
   CHECK(cert_verifier_);
   CHECK(transport_security_state_);
   CHECK(cert_transparency_verifier_);
   CHECK(policy_enforcer_);
 }
 
 SSLClientSocketImpl::~SSLClientSocketImpl() {
   Disconnect();
 }
@@ skipping 154 matching lines @@
   // Note that this does not check |BIO_pending|, whether there is ciphertext
   // that has not yet been flushed to the network. |Write| returns early, so
   // this can cause race conditions which cause a socket to not be treated
   // reusable when it should be. See https://crbug.com/466147.
   if (BIO_wpending(transport_bio_.get()) > 0)
     return false;
 
   return transport_->socket()->IsConnectedAndIdle();
 }
 
+void SSLClientSocketImpl::OnAddedToPool() {
+  in_pool_ = true;
+}
+
+void SSLClientSocketImpl::OnRemovedFromPool() {
+  in_pool_ = false;
+}
+
 int SSLClientSocketImpl::GetPeerAddress(IPEndPoint* addressList) const {
   return transport_->socket()->GetPeerAddress(addressList);
 }
 
 int SSLClientSocketImpl::GetLocalAddress(IPEndPoint* addressList) const {
   return transport_->socket()->GetLocalAddress(addressList);
 }
 
 const NetLogWithSource& SSLClientSocketImpl::NetLog() const {
   return net_log_;
@@ skipping 72 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 {
+  base::trace_event::MemoryAllocatorDump* socket_dump =
+      dump->process_memory_dump()->CreateAllocatorDump(base::StringPrintf(
+          "%s/ssl_socket/%p", dump->absolute_name().c_str(), this));
+  size_t total_buffer_size =
+      send_buffer_->capacity() + recv_buffer_->capacity();
+  size_t buffer_count = 2;
+  socket_dump->AddScalar("buffers_size",
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                         total_buffer_size);
+  socket_dump->AddScalar("buffer_count",
+                         base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+                         buffer_count);
+
+  size_t total_cert_size = 0;
+  size_t cert_count = 0;
+  auto cert_chain = ssl_ ? SSL_get_peer_cert_chain(ssl_.get()) : nullptr;
+  if (cert_chain) {
+    cert_count = sk_X509_num(cert_chain);
+    for (size_t i = 0; i != cert_count; ++i) {
+      X509* cert = sk_X509_value(cert_chain, i);
+      total_cert_size += i2d_X509(cert, nullptr);
+    }
+  }
+  socket_dump->AddScalar("certs_size",
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                         total_cert_size);
+  socket_dump->AddScalar("cert_count",
+                         base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+                         cert_count);
+
+  size_t total_size = total_buffer_size + total_cert_size;
+  socket_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                         total_size);
+
+  socket_dump->AddScalar(
+      "socket_count", base::trace_event::MemoryAllocatorDump::kUnitsObjects, 1);
+}
+
 int SSLClientSocketImpl::Read(IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback) {
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
 
   int rv = DoReadLoop();
 
   if (rv == ERR_IO_PENDING) {
     user_read_callback_ = callback;
@@ skipping 1466 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