[Not for review] Add TRACE_EVENTs and chrome://flags for preconnect

net/quic/core/quic_crypto_client_stream.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/quic/core/quic_crypto_client_stream.h"
 
 #include <memory>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/trace_event/trace_event.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/crypto/null_encrypter.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_session.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 
@@ skipping 89 matching lines @@
   if (channel_id_source_callback_) {
     channel_id_source_callback_->Cancel();
   }
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
 }
 
 void QuicCryptoClientStream::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
+  TRACE_EVENT1("net", "QuicCryptoClientStream::OnHandshakeMessage", "host",
+               server_id_.host());
   QuicCryptoClientStreamBase::OnHandshakeMessage(message);
 
   if (message.tag() == kSCUP) {
     if (!handshake_confirmed()) {
       CloseConnectionWithDetails(QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE,
                                  "Early SCUP disallowed");
       return;
     }
 
     // |message| is an update from the server, so we treat it differently from a
@@ skipping 55 matching lines @@
 
   DCHECK(handshake_confirmed());
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
   next_state_ = STATE_INITIALIZE_SCUP;
   DoHandshakeLoop(nullptr);
 }
 
 void QuicCryptoClientStream::DoHandshakeLoop(const CryptoHandshakeMessage* in) {
+  TRACE_EVENT1("net", "QuicCryptoClientStream::DoHandshakeLoop", "host",
+               server_id_.host());
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_->LookupOrCreate(server_id_);
 
   QuicAsyncStatus rv = QUIC_SUCCESS;
   do {
     CHECK_NE(STATE_NONE, next_state_);
     const State state = next_state_;
     next_state_ = STATE_IDLE;
     rv = QUIC_SUCCESS;
     switch (state) {
@@ skipping 49 matching lines @@
     chlo_hash_ = cached->chlo_hash();
     // If the cached state needs to be verified, do it now.
     next_state_ = STATE_VERIFY_PROOF;
   } else {
     next_state_ = STATE_GET_CHANNEL_ID;
   }
 }
 
 void QuicCryptoClientStream::DoSendCHLO(
     QuicCryptoClientConfig::CachedState* cached) {
+  TRACE_EVENT1("net", "QuicCryptoClientStream::DoSendCHLO", "host",
+               server_id_.host());
   if (stateless_reject_received_) {
     // If we've gotten to this point, we've sent at least one hello
     // and received a stateless reject in response.  We cannot
     // continue to send hellos because the server has abandoned state
     // for this connection.  Abandon further handshakes.
     next_state_ = STATE_NONE;
     if (session()->connection()->connected()) {
       session()->connection()->CloseConnection(
           QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, "stateless reject received",
           ConnectionCloseBehavior::SILENT_CLOSE);
@@ skipping 166 matching lines @@
       // has happened since then.
       next_state_ = STATE_VERIFY_PROOF;
       return;
     }
   }
   next_state_ = STATE_GET_CHANNEL_ID;
 }
 
 QuicAsyncStatus QuicCryptoClientStream::DoVerifyProof(
     QuicCryptoClientConfig::CachedState* cached) {
+  TRACE_EVENT1("net", "QuicCryptoClientStream::DoVerifyProof", "host",
+               server_id_.host());
   ProofVerifier* verifier = crypto_config_->proof_verifier();
   DCHECK(verifier);
   next_state_ = STATE_VERIFY_PROOF_COMPLETE;
   generation_counter_ = cached->generation_counter();
 
   ProofVerifierCallbackImpl* proof_verify_callback =
       new ProofVerifierCallbackImpl(this);
 
   verify_ok_ = false;
 
@@ skipping 211 matching lines @@
   }
   for (size_t i = 0; i < num_their_proof_demands; i++) {
     if (their_proof_demands[i] == kCHID) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net