Make URLRequestContext a MemoryDumpProvider (Abandoned)

net/ssl/ssl_client_session_cache.cc

 // Copyright 2015 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/ssl/ssl_client_session_cache.h"
 
+#include <openssl/ssl.h>
+#include <openssl/x509.h>
 #include <utility>
 
 #include "base/memory/memory_coordinator_client_registry.h"
+#include "base/strings/stringprintf.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
+#include "base/trace_event/process_memory_dump.h"
+#include "net/cert/x509_util_openssl.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 
 namespace net {
 
 SSLClientSessionCache::SSLClientSessionCache(const Config& config)
     : clock_(new base::DefaultClock),
       config_(config),
       cache_(config.max_entries),
       lookups_since_flush_(0) {
   memory_pressure_listener_.reset(new base::MemoryPressureListener(base::Bind(
@@ skipping 53 matching lines @@
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 bool SSLClientSessionCache::IsExpired(SSL_SESSION* session, time_t now) {
   return now < SSL_SESSION_get_time(session) ||
          now >=
              SSL_SESSION_get_time(session) + SSL_SESSION_get_timeout(session);
 }
 
+void SSLClientSessionCache::DumpMemoryStats(
+    base::trace_event::ProcessMemoryDump* pmd) const {
+  std::string absolute_name = "net/ssl_session_cache";
+  base::trace_event::MemoryAllocatorDump* cache_dump =
+      pmd->GetAllocatorDump(absolute_name);
+  // This is a singleton, so only log it once.
+  if (cache_dump)
+    return;
+  cache_dump = pmd->CreateAllocatorDump(absolute_name);
+  auto iter = cache_.begin();

[eroman, 2016/11/29 22:22:50]

I would expect |lock_| should be held while accessing cache_, although the class
doesn't really document its threadsafety or for that matter enforce it
everywhere (SSLClientSessionCache::size() for instance doesn't acquire a lock,
so perhaps I have misunderstood its intention?)

[xunjieli, 2016/11/30 16:02:03]

Done.

David, do you know why some methods that access |cache_| are not lock protected?
eg. size() and FlushExpiredSessions() which is called from OnMemoryStateChange()
?

+  while (iter != cache_.end()) {
+    auto entry = iter->second.get();
+    auto cert_chain = entry->x509_chain;
+    size_t cert_count = sk_X509_num(cert_chain);
+    base::trace_event::MemoryAllocatorDump* entry_dump =
+        pmd->CreateAllocatorDump(
+            base::StringPrintf("%s/entry_%p", absolute_name.c_str(), entry));
+    int cert_size = 0;
+    for (size_t i = 0; i < cert_count; ++i) {
+      X509* cert = sk_X509_value(cert_chain, i);
+      cert_size += i2d_X509(cert, nullptr);
+    }
+    entry_dump->AddScalar("cert_size",
+                          base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                          cert_size);
+    entry_dump->AddScalar("cert_count",
+                          base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+                          cert_count);
+    entry_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                          base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                          cert_size);
+
+    ++iter;
+  }
+}
+
 void SSLClientSessionCache::FlushExpiredSessions() {
   time_t now = clock_->Now().ToTimeT();
   auto iter = cache_.begin();
   while (iter != cache_.end()) {
     if (IsExpired(iter->second.get(), now)) {
       iter = cache_.Erase(iter);
     } else {
       ++iter;
     }
   }
@@ skipping 25 matching lines @@
       break;
     case base::MemoryState::SUSPENDED:
     // Note: Not supported at present. Fall through.
     case base::MemoryState::UNKNOWN:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace net