Update from https://crrev.com/308996

net/socket/ssl_client_socket_openssl.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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <errno.h>
@@ skipping 909 matching lines @@
 int SSLClientSocketOpenSSL::DoHandshake() {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "424386 SSLClientSocketOpenSSL::DoHandshake1"));
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
   int net_error = OK;
   int rv = SSL_do_handshake(ssl_);
 
-  // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
-  tracked_objects::ScopedTracker tracking_profile2(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "424386 SSLClientSocketOpenSSL::DoHandshake2"));
+  if (client_auth_cert_needed_) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile2(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLClientSocketOpenSSL::DoHandshake2"));
 
-  if (client_auth_cert_needed_) {
     net_error = ERR_SSL_CLIENT_AUTH_CERT_NEEDED;
     // If the handshake already succeeded (because the server requests but
     // doesn't require a client cert), we need to invalidate the SSL session
     // so that we won't try to resume the non-client-authenticated session in
     // the next handshake.  This will cause the server to ask for a client
     // cert again.
     if (rv == 1) {
       // Remove from session cache but don't clear this connection.
       SSL_SESSION* session = SSL_get_session(ssl_);
       if (session) {
         int rv = SSL_CTX_remove_session(SSL_get_SSL_CTX(ssl_), session);
         LOG_IF(WARNING, !rv) << "Couldn't invalidate SSL session: " << session;
       }
     }
   } else if (rv == 1) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile3(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLClientSocketOpenSSL::DoHandshake3"));
+
     if (trying_cached_session_ && logging::DEBUG_MODE) {
       DVLOG(2) << "Result of session reuse for " << host_and_port_.ToString()
                << " is: " << (SSL_session_reused(ssl_) ? "Success" : "Fail");
     }
 
     if (ssl_config_.version_fallback &&
         ssl_config_.version_max < ssl_config_.version_fallback_min) {
       return ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION;
     }
 
@@ skipping 27 matching lines @@
 
     const uint8_t* sct_list;
     size_t sct_list_len;
     SSL_get0_signed_cert_timestamp_list(ssl_, &sct_list, &sct_list_len);
     set_signed_cert_timestamps_received(sct_list_len != 0);
 
     // Verify the certificate.
     UpdateServerCert();
     GotoState(STATE_VERIFY_CERT);
   } else {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+    tracked_objects::ScopedTracker tracking_profile4(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "424386 SSLClientSocketOpenSSL::DoHandshake4"));
+
     int ssl_error = SSL_get_error(ssl_, rv);
 
     if (ssl_error == SSL_ERROR_WANT_CHANNEL_ID_LOOKUP) {
       // The server supports channel ID. Stop to look one up before returning to
       // the handshake.
       channel_id_xtn_negotiated_ = true;
       GotoState(STATE_CHANNEL_ID_LOOKUP);
       return OK;
     }
 
@@ skipping 185 matching lines @@
   if (rv < OK)
     OnHandshakeCompletion();
   if (!user_connect_callback_.is_null()) {
     CompletionCallback c = user_connect_callback_;
     user_connect_callback_.Reset();
     c.Run(rv > OK ? OK : rv);
   }
 }
 
 void SSLClientSocketOpenSSL::UpdateServerCert() {
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424386 SSLClientSocketOpenSSL::UpdateServerCert"));
+
   server_cert_chain_->Reset(SSL_get_peer_cert_chain(ssl_));
   server_cert_ = server_cert_chain_->AsOSChain();
 
   if (server_cert_.get()) {
     net_log_.AddEvent(
         NetLog::TYPE_SSL_CERTIFICATES_RECEIVED,
         base::Bind(&NetLogX509CertificateCallback,
                    base::Unretained(server_cert_.get())));
 
     // TODO(rsleevi): Plumb an OCSP response into the Mac system library and
@@ skipping 51 matching lines @@
       &ct_verify_result_, net_log_);
 
   if (!policy_enforcer_) {
     server_cert_verify_result_.cert_status &= ~CERT_STATUS_IS_EV;
   } else {
     if (server_cert_verify_result_.cert_status & CERT_STATUS_IS_EV) {
       scoped_refptr<ct::EVCertsWhitelist> ev_whitelist =
           SSLConfigService::GetEVCertsWhitelist();
       if (!policy_enforcer_->DoesConformToCTEVPolicy(
               server_cert_verify_result_.verified_cert.get(),
-              ev_whitelist.get(), ct_verify_result_)) {
+              ev_whitelist.get(), ct_verify_result_, net_log_)) {
         // TODO(eranm): Log via the BoundNetLog, see crbug.com/437766
         VLOG(1) << "EV certificate for "
                 << server_cert_verify_result_.verified_cert->subject()
                        .GetDisplayName()
                 << " does not conform to CT policy, removing EV status.";
         server_cert_verify_result_.cert_status &= ~CERT_STATUS_IS_EV;
       }
     }
   }
 }
@@ skipping 577 matching lines @@
   }
   return retvalue;
 }
 
 // static
 long SSLClientSocketOpenSSL::BIOCallback(
     BIO *bio,
     int cmd,
     const char *argp, int argi, long argl,
     long retvalue) {
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424386 SSLClientSocketOpenSSL::BIOCallback"));
+
   SSLClientSocketOpenSSL* socket = reinterpret_cast<SSLClientSocketOpenSSL*>(
       BIO_get_callback_arg(bio));
   CHECK(socket);
   return socket->MaybeReplayTransportError(
       bio, cmd, argp, argi, argl, retvalue);
 }
 
 // static
 void SSLClientSocketOpenSSL::InfoCallback(const SSL* ssl,
                                           int type,
                                           int /*val*/) {
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/424386 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424386 SSLClientSocketOpenSSL::InfoCallback"));
+
   if (type == SSL_CB_HANDSHAKE_DONE) {
     SSLClientSocketOpenSSL* ssl_socket =
         SSLContext::GetInstance()->GetClientSocketFromSSL(ssl);
     ssl_socket->handshake_succeeded_ = true;
     ssl_socket->CheckIfHandshakeFinished();
   }
 }
 
 // Determines if both the handshake and certificate verification have completed
 // successfully, and calls the handshake completion callback if that is the
@@ skipping 30 matching lines @@
                                             ct::SCT_STATUS_LOG_UNKNOWN));
   }
 }
 
 scoped_refptr<X509Certificate>
 SSLClientSocketOpenSSL::GetUnverifiedServerCertificateChain() const {
   return server_cert_;
 }
 
 }  // namespace net