Add a multiplier in tracking certificate memory allocation size

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 <algorithm>
@@ skipping 826 matching lines @@
 int64_t SSLClientSocketImpl::GetTotalReceivedBytes() const {
   return transport_->socket()->GetTotalReceivedBytes();
 }
 
 void SSLClientSocketImpl::DumpMemoryStats(SocketMemoryStats* stats) const {
   if (transport_adapter_)
     stats->buffer_size = transport_adapter_->GetAllocationSize();
   if (server_cert_chain_) {
     for (size_t i = 0; i < server_cert_chain_->size(); ++i) {
       X509* cert = server_cert_chain_->Get(i);
-      // This measures the lower bound of the serialized certificate. It doesn't
-      // measure the actual memory used, which is 4x this amount (see
-      // crbug.com/671420 for more details).
-      stats->serialized_cert_size += i2d_X509(cert, nullptr);
+      // Estimate the size of the certificate before deduplication.
+      // The multiplier (4) is added to account for the difference between the
+      // serialized cert size and the actual cert allocation.
+      // TODO(xunjieli): Update this after crbug.com/671420 is done.
+      stats->cert_size += 4 * i2d_X509(cert, nullptr);

[xunjieli, 2017/02/16 22:54:24]

I didn't find a way to track distinct X509*. This function is many layers down
from the actual iteration (client_socket_pool_base.cc and spdy_session_pool.cc).
If I pass in a pointer to std::set as a function argument and do operation on
it, there seems to be some optimization that prevents the set<> from seeing
insertions from other loop iterations.


I used a std::unordered_set in ssl_client_session_cache.cc where calculation is
all at one place.

     }
     stats->cert_count = server_cert_chain_->size();
   }
-  stats->total_size = stats->buffer_size + stats->serialized_cert_size;
+  stats->total_size = stats->buffer_size + stats->cert_size;
 }
 
 // static
 void SSLClientSocketImpl::DumpSSLClientSessionMemoryStats(
     base::trace_event::ProcessMemoryDump* pmd) {
   SSLContext::GetInstance()->session_cache()->DumpMemoryStats(pmd);
 }
 
 int SSLClientSocketImpl::Read(IOBuffer* buf,
                               int buf_len,
@@ skipping 1178 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