[NOT FOR LANDING] Detailed loading traces

net/cert/x509_certificate.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/cert/x509_certificate.h"
 
 #include <limits.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
+#include "base/trace_event/trace_event.h"
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/pickle.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sha1.h"
@@ skipping 233 matching lines @@
 scoped_refptr<X509Certificate> X509Certificate::CreateFromHandle(
     OSCertHandle cert_handle,
     const OSCertHandles& intermediates) {
   DCHECK(cert_handle);
   return new X509Certificate(cert_handle, intermediates);
 }
 
 // static
 scoped_refptr<X509Certificate> X509Certificate::CreateFromDERCertChain(
     const std::vector<base::StringPiece>& der_certs) {
+  TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain");
+
   // TODO(cbentzel): Remove ScopedTracker below once crbug.com/424386 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "424386 X509Certificate::CreateFromDERCertChain"));
 
   if (der_certs.empty())
     return NULL;
 
+  TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain::A");
+
   X509Certificate::OSCertHandles intermediate_ca_certs;
   for (size_t i = 1; i < der_certs.size(); i++) {
     OSCertHandle handle = CreateOSCertHandleFromBytes(
         const_cast<char*>(der_certs[i].data()), der_certs[i].size());
     if (!handle)
       break;
     intermediate_ca_certs.push_back(handle);
   }
 
+  TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain::B");
   OSCertHandle handle = NULL;
   // Return NULL if we failed to parse any of the certs.
   if (der_certs.size() - 1 == intermediate_ca_certs.size()) {
     handle = CreateOSCertHandleFromBytes(
         const_cast<char*>(der_certs[0].data()), der_certs[0].size());
   }
+  TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain::C");
 
   scoped_refptr<X509Certificate> cert = nullptr;
   if (handle) {
+    TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain::C.1");
     cert = CreateFromHandle(handle, intermediate_ca_certs);
+    TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain::C.2");
     FreeOSCertHandle(handle);
   }
+  TRACE_EVENT0("toplevel", "X509Certificate::CreateFromDERCertChain::D");
 
   for (size_t i = 0; i < intermediate_ca_certs.size(); i++)
     FreeOSCertHandle(intermediate_ca_certs[i]);
 
   return cert;
 }
 
 // static
 scoped_refptr<X509Certificate> X509Certificate::CreateFromBytes(
     const char* data,
     size_t length) {
   OSCertHandle cert_handle = CreateOSCertHandleFromBytes(data, length);
   if (!cert_handle)
     return NULL;
 
   scoped_refptr<X509Certificate> cert =
       CreateFromHandle(cert_handle, OSCertHandles());
   FreeOSCertHandle(cert_handle);
   return cert;
 }
 
 // static
 scoped_refptr<X509Certificate> X509Certificate::CreateFromPickle(
     base::PickleIterator* pickle_iter,
     PickleType type) {
+  TRACE_EVENT0("toplevel", "X509Certificate::CreateFromPickle");
+
   if (type == PICKLETYPE_CERTIFICATE_CHAIN_V3) {
     int chain_length = 0;
     if (!pickle_iter->ReadLength(&chain_length))
       return NULL;
 
     std::vector<base::StringPiece> cert_chain;
     const char* data = NULL;
     int data_length = 0;
     for (int i = 0; i < chain_length; ++i) {
+      TRACE_EVENT0("toplevel", "X509Certificate::CreateFromPickle::A");
       if (!pickle_iter->ReadData(&data, &data_length))
         return NULL;
+      TRACE_EVENT0("toplevel", "X509Certificate::CreateFromPickle::B");
       cert_chain.push_back(base::StringPiece(data, data_length));
     }
     return CreateFromDERCertChain(cert_chain);
   }
 
   // Legacy / Migration code. This should eventually be removed once
   // sufficient time has passed that all pickles serialized prior to
   // PICKLETYPE_CERTIFICATE_CHAIN_V3 have been removed.
   OSCertHandle cert_handle = ReadOSCertHandleFromPickle(pickle_iter);
   if (!cert_handle)
@@ skipping 29 matching lines @@
       // the pickle, we should report success. Note that it is technically
       // possible for us to skip over zeroes that should have occurred after
       // an empty certificate list; to avoid this going forward, only do this
       // backward-compatibility stuff for PICKLETYPE_CERTIFICATE_CHAIN_V1
       // which comes from the pickle version number in http_response_info.cc.
       if (num_intermediates) {
         FreeOSCertHandle(cert_handle);
         return NULL;
       }
     }
+
     if (zero_check)
       *pickle_iter = saved_iter;
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX) && defined(__x86_64__)
 
     for (uint32_t i = 0; i < num_intermediates; ++i) {
       OSCertHandle intermediate = ReadOSCertHandleFromPickle(pickle_iter);
       if (!intermediate)
         break;
       intermediates.push_back(intermediate);
     }
@@ skipping 344 matching lines @@
   OSCertHandles chain;
   chain.push_back(leaf);
   chain.insert(chain.end(), intermediates.begin(), intermediates.end());
 
   return CalculateCAFingerprint256(chain);
 }
 
 X509Certificate::X509Certificate(OSCertHandle cert_handle,
                                  const OSCertHandles& intermediates)
     : cert_handle_(DupOSCertHandle(cert_handle)) {
+  TRACE_EVENT0("toplevel", "X509Certificate::X509Certificate::A");
   InsertOrUpdateCache(&cert_handle_);
+  TRACE_EVENT0("toplevel", "X509Certificate::X509Certificate::B");
   for (size_t i = 0; i < intermediates.size(); ++i) {
     // Duplicate the incoming certificate, as the caller retains ownership
     // of |intermediates|.
     OSCertHandle intermediate = DupOSCertHandle(intermediates[i]);
     // Update the cache, which will assume ownership of the duplicated
     // handle and return a suitable equivalent, potentially from the cache.
     InsertOrUpdateCache(&intermediate);
     intermediate_ca_certs_.push_back(intermediate);
   }
+  TRACE_EVENT0("toplevel", "X509Certificate::X509Certificate::C");
   // Platform-specific initialization.
   Initialize();
 }
 
 X509Certificate::~X509Certificate() {
   if (cert_handle_) {
     RemoveFromCache(cert_handle_);
     FreeOSCertHandle(cert_handle_);
   }
   for (size_t i = 0; i < intermediate_ca_certs_.size(); ++i) {
     RemoveFromCache(intermediate_ca_certs_[i]);
     FreeOSCertHandle(intermediate_ca_certs_[i]);
   }
 }
 
 }  // namespace net