[NOT FOR LANDING] Detailed loading traces

net/http/http_response_info.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/http/http_response_info.h"
 
+#include "base/trace_event/trace_event.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/cert/signed_certificate_timestamp.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/http_response_headers.h"
 #include "net/ssl/ssl_cert_request_info.h"
@@ skipping 112 matching lines @@
       request_time(rhs.request_time),
       response_time(rhs.response_time),
       auth_challenge(rhs.auth_challenge),
       cert_request_info(rhs.cert_request_info),
       ssl_info(rhs.ssl_info),
       headers(rhs.headers),
       vary_data(rhs.vary_data),
       metadata(rhs.metadata) {}
 
 HttpResponseInfo::~HttpResponseInfo() {
+  TRACE_EVENT0("toplevel", "HttpResponseInfo::~HttpResponseInfo");
 }
 
 HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) {
   was_cached = rhs.was_cached;
   server_data_unavailable = rhs.server_data_unavailable;
   network_accessed = rhs.network_accessed;
   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
   proxy_server = rhs.proxy_server;
   was_npn_negotiated = rhs.was_npn_negotiated;
   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
@@ skipping 11 matching lines @@
   headers = rhs.headers;
   vary_data = rhs.vary_data;
   metadata = rhs.metadata;
   return *this;
 }
 
 bool HttpResponseInfo::InitFromPickle(const base::Pickle& pickle,
                                       bool* response_truncated) {
   base::PickleIterator iter(pickle);
 
+  TRACE_EVENT0("toplevel", "HttpResponseInfo::InitFromPickle::A");
+
   // Read flags and verify version
   int flags;
   if (!iter.ReadInt(&flags))
     return false;
   int version = flags & RESPONSE_INFO_VERSION_MASK;
   if (version < RESPONSE_INFO_MINIMUM_VERSION ||
       version > RESPONSE_INFO_VERSION) {
     DLOG(ERROR) << "unexpected response info version: " << version;
     return false;
   }
@@ skipping 15 matching lines @@
   if (headers->response_code() == -1)
     return false;
 
   // Read ssl-info
   if (flags & RESPONSE_INFO_HAS_CERT) {
     X509Certificate::PickleType type = GetPickleTypeForVersion(version);
     ssl_info.cert = X509Certificate::CreateFromPickle(&iter, type);
     if (!ssl_info.cert.get())
       return false;
   }
+
   if (flags & RESPONSE_INFO_HAS_CERT_STATUS) {
     CertStatus cert_status;
     if (!iter.ReadUInt32(&cert_status))
       return false;
     ssl_info.cert_status = cert_status;
   }
+
   if (flags & RESPONSE_INFO_HAS_SECURITY_BITS) {
     int security_bits;
     if (!iter.ReadInt(&security_bits))
       return false;
     ssl_info.security_bits = security_bits;
   }
 
   if (flags & RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS) {
     int connection_status;
     if (!iter.ReadInt(&connection_status))
@@ skipping 208 matching lines @@
     case CONNECTION_INFO_QUIC1_SPDY3:
       return "quic/1+spdy/3";
     case NUM_OF_CONNECTION_INFOS:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace net