Update from https://crrev.com/308996

net/socket/ssl_session_cache_openssl.cc

 // Copyright 2013 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_session_cache_openssl.h"
 
 #include <list>
 #include <map>
 
 #include <openssl/rand.h>
 #include <openssl/ssl.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/profiler/scoped_tracker.h"
 #include "base/synchronization/lock.h"
 
 namespace net {
 
 namespace {
 
 // A helper class to lazily create a new EX_DATA index to map SSL_CTX handles
 // to their corresponding SSLSessionCacheOpenSSLImpl object.
 class SSLContextExIndex {
 public:
@@ skipping 123 matching lines @@
 
 class SSLSessionCacheOpenSSLImpl {
  public:
   // Construct new instance. This registers various hooks into the SSL_CTX
   // context |ctx|. OpenSSL will call back during SSL connection
   // operations. |key_func| is used to map a SSL handle to a unique cache
   // string, according to the client's preferences.
   SSLSessionCacheOpenSSLImpl(SSL_CTX* ctx,
                              const SSLSessionCacheOpenSSL::Config& config)
       : ctx_(ctx), config_(config), expiration_check_(0) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::SSLSessionCacheOpenSSLImpl"));
+
     DCHECK(ctx);
 
     // NO_INTERNAL_STORE disables OpenSSL's builtin cache, and
     // NO_AUTO_CLEAR disables the call to SSL_CTX_flush_sessions
     // every 256 connections (this number is hard-coded in the library
     // and can't be changed).
     SSL_CTX_set_session_cache_mode(ctx_,
                                    SSL_SESS_CACHE_CLIENT |
                                        SSL_SESS_CACHE_NO_INTERNAL_STORE |
                                        SSL_SESS_CACHE_NO_AUTO_CLEAR);
@@ skipping 20 matching lines @@
 
   // Retrieve the cache key from |ssl| and look for a corresponding
   // cached session ID. If one is found, call SSL_set_session() to associate
   // it with the |ssl| connection.
   //
   // Will also check for expired sessions every |expiration_check_count|
   // calls.
   //
   // Return true if a cached session ID was found, false otherwise.
   bool SetSSLSession(SSL* ssl) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::SetSSLSession"));
+
     std::string cache_key = config_.key_func(ssl);
     if (cache_key.empty())
       return false;
 
     return SetSSLSessionWithKey(ssl, cache_key);
   }
 
   // Variant of SetSSLSession to be used when the client already has computed
   // the cache key. Avoid a call to the configuration's |key_func| function.
   bool SetSSLSessionWithKey(SSL* ssl, const std::string& cache_key) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::SetSSLSessionWithKey"));
+
     base::AutoLock locked(lock_);
 
     DCHECK_EQ(config_.key_func(ssl), cache_key);
 
     if (++expiration_check_ >= config_.expiration_check_count) {
       expiration_check_ = 0;
       FlushExpiredSessionsLocked();
     }
 
     KeyIndex::iterator it = key_index_.find(cache_key);
@@ skipping 13 matching lines @@
     // Move to front of MRU list.
     ordering_.push_front(session);
     ordering_.erase(it->second);
     it->second = ordering_.begin();
 
     return SSL_set_session(ssl, session) == 1;
   }
 
   // Return true iff a cached session was associated with the given |cache_key|.
   bool SSLSessionIsInCache(const std::string& cache_key) const {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::SSLSessionIsInCache"));
+
     base::AutoLock locked(lock_);
     KeyIndex::const_iterator it = key_index_.find(cache_key);
     if (it == key_index_.end())
       return false;
 
     SSL_SESSION* session = *it->second;
     DCHECK(session);
 
     void* session_is_good =
         SSL_SESSION_get_ex_data(session, GetSSLSessionExIndex());
 
     return session_is_good != NULL;
   }
 
   void MarkSSLSessionAsGood(SSL* ssl) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::MarkSSLSessionAsGood"));
+
     SSL_SESSION* session = SSL_get_session(ssl);
     CHECK(session);
 
     // Mark the session as good, allowing it to be used for future connections.
     SSL_SESSION_set_ex_data(
         session, GetSSLSessionExIndex(), reinterpret_cast<void*>(1));
   }
 
   // Flush all entries from the cache.
   void Flush() {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::Flush"));
+
     base::AutoLock lock(lock_);
     id_index_.clear();
     key_index_.clear();
     while (!ordering_.empty()) {
       SSL_SESSION* session = ordering_.front();
       ordering_.pop_front();
       SSL_SESSION_free(session);
     }
   }
 
@@ skipping 74 matching lines @@
     DCHECK(result);
     return reinterpret_cast<SSLSessionCacheOpenSSLImpl*>(result);
   }
 
   // Called by OpenSSL when a new |session| was created and added to a given
   // |ssl| connection. Note that the session's reference count was already
   // incremented before the function is entered. The function must return 1
   // to indicate that it took ownership of the session, i.e. that the caller
   // should not decrement its reference count after completion.
   static int NewSessionCallbackStatic(SSL* ssl, SSL_SESSION* session) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::NewSessionCallbackStatic"));
+
     SSLSessionCacheOpenSSLImpl* cache = GetCache(ssl->ctx);
     cache->OnSessionAdded(ssl, session);
     return 1;
   }
 
   // Called by OpenSSL to indicate that a session must be removed from the
   // cache. This happens when SSL_CTX is destroyed.
   static void RemoveSessionCallbackStatic(SSL_CTX* ctx, SSL_SESSION* session) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::RemoveSessionCallbackStatic"));
+
     GetCache(ctx)->OnSessionRemoved(session);
   }
 
   // Called by OpenSSL to generate a new session ID. This happens during a
   // SSL connection operation, when the SSL object doesn't have a session yet.
   //
   // A session ID is a random string of bytes used to uniquely identify the
   // session between a client and a server.
   //
   // |ssl| is a SSL connection handle. Ignored here.
   // |id| is the target buffer where the ID must be generated.
   // |*id_len| is, on input, the size of the desired ID. It will be 16 for
   // SSLv2, and 32 for anything else. OpenSSL allows an implementation
   // to change it on output, but this will not happen here.
   //
   // The function must ensure the generated ID is really unique, i.e. that
   // another session in the cache doesn't already use the same value. It must
   // return 1 to indicate success, or 0 for failure.
   static int GenerateSessionIdStatic(const SSL* ssl,
                                      unsigned char* id,
                                      unsigned* id_len) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLSessionCacheOpenSSLImpl::GenerateSessionIdStatic"));
+
     if (!GetCache(ssl->ctx)->OnGenerateSessionId(id, *id_len))
       return 0;
 
     return 1;
   }
 
   // Add |session| to the cache in association with |cache_key|. If a session
   // already exists, it is replaced with the new one. This assumes that the
   // caller already incremented the session's reference count.
   void OnSessionAdded(SSL* ssl, SSL_SESSION* session) {
@@ skipping 121 matching lines @@
   return impl_->SSLSessionIsInCache(cache_key);
 }
 
 void SSLSessionCacheOpenSSL::MarkSSLSessionAsGood(SSL* ssl) {
   return impl_->MarkSSLSessionAsGood(ssl);
 }
 
 void SSLSessionCacheOpenSSL::Flush() { impl_->Flush(); }
 
 }  // namespace net