Unwind the SSL connection holdback experiment and remove related code

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>
@@ skipping 235 matching lines @@
       return false;  // Session has not yet been marked good. Treat as a miss.
 
     // 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);
+    if (!session)
+      return;
 
     // 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(
@@ skipping 92 matching lines @@
   // |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);
+    GetCache(ssl->ctx)->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"));
@@ skipping 116 matching lines @@
     DLOG(ERROR) << "Couldn't generate unique session ID of " << id_len
                 << "bytes after " << kMaxTries << " tries.";
     return false;
   }
 
   SSL_CTX* ctx_;
   SSLSessionCacheOpenSSL::Config config_;
 
   // method to get the index which can later be used with SSL_CTX_get_ex_data()
   // or SSL_CTX_set_ex_data().
-  mutable base::Lock lock_;  // Protects access to containers below.
+  base::Lock lock_;  // Protects access to containers below.
 
   MRUSessionList ordering_;
   KeyIndex key_index_;
   SessionIdIndex id_index_;
 
   size_t expiration_check_;
 };
 
 SSLSessionCacheOpenSSL::~SSLSessionCacheOpenSSL() { delete impl_; }
 
 size_t SSLSessionCacheOpenSSL::size() const { return impl_->size(); }
 
 void SSLSessionCacheOpenSSL::Reset(SSL_CTX* ctx, const Config& config) {
   if (impl_)
     delete impl_;
 
   impl_ = new SSLSessionCacheOpenSSLImpl(ctx, config);
 }
 
 bool SSLSessionCacheOpenSSL::SetSSLSession(SSL* ssl) {
   return impl_->SetSSLSession(ssl);
 }
 
 bool SSLSessionCacheOpenSSL::SetSSLSessionWithKey(
     SSL* ssl,
     const std::string& cache_key) {
   return impl_->SetSSLSessionWithKey(ssl, cache_key);
 }
 
-bool SSLSessionCacheOpenSSL::SSLSessionIsInCache(
-    const std::string& cache_key) const {
-  return impl_->SSLSessionIsInCache(cache_key);
-}
-
 void SSLSessionCacheOpenSSL::MarkSSLSessionAsGood(SSL* ssl) {
   return impl_->MarkSSLSessionAsGood(ssl);
 }
 
 void SSLSessionCacheOpenSSL::Flush() { impl_->Flush(); }
 
 }  // namespace net