Add TRACE_EVENT macros to net.

net/http/http_stream_factory_impl_job.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_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/port_util.h"
 #include "net/cert/cert_verifier.h"
 #include "net/http/bidirectional_stream_impl.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
@@ skipping 483 matching lines @@
     SSLFailureState ssl_failure_state =
         connection_ ? connection_->ssl_failure_state() : SSL_FAILURE_NONE;
     request_->OnStreamFailed(this, result, server_ssl_config_,
                              ssl_failure_state);
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnCertificateErrorCallback(
     int result, const SSLInfo& ssl_info) {
+  TRACE_EVENT0("net", "HttpStreamFactoryImpl::Job::OnCertificateErrorCallback");

[mmenke, 2016/03/28 20:46:51]

How are you planning on using these?  Seems like basing memory attribution logic
on code like this this would claim something like
"HttpStreamFactoryImpl::Job::OnCertificateErrorCallback" is taking a lot of
memory, while in reality, the problem would be the entire tree of calls below
OnCertificateErrorCallback, none of which involve HttpStreamFactoryImpl::Job. 

[ssid, 2016/03/29 00:33:06]

I agree, in general the answer to your question is: I will try to add tracing
points to more functions in the tree of calls under these function if I know
what are these functions are useful. I am hoping that by these instrumentation,
I can at least understand one more level deeper, if not all the way and tell
what is responsible for memory.

In specific, adding to OnCertificateErrorCallback was a mistake. It does not
give any information, nor the callbacks allocate memory. Sorry. I removed this.

   DCHECK(!IsPreconnecting());
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   if (IsOrphaned())
     stream_factory_->OnOrphanedJobComplete(this);
   else
     request_->OnCertificateError(this, result, server_ssl_config_, ssl_info);
   // |this| may be deleted after this call.
 }
@@ skipping 62 matching lines @@
                                                  net_log)
              ? ERR_SPDY_SESSION_ALREADY_EXISTS
              : OK;
 }
 
 void HttpStreamFactoryImpl::Job::OnIOComplete(int result) {
   RunLoop(result);
 }
 
 int HttpStreamFactoryImpl::Job::RunLoop(int result) {
+  TRACE_EVENT0("net", "HttpStreamFactoryImpl::Job::RunLoop");
   result = DoLoop(result);
 
   if (result == ERR_IO_PENDING)
     return result;
 
   // If there was an error, we should have already resumed the |waiting_job_|,
   // if there was one.
   DCHECK(result == OK || waiting_job_ == NULL);
 
   if (IsPreconnecting()) {
@@ skipping 1174 matching lines @@
   if (connection_->socket()) {
     ConnectionAttempts socket_attempts;
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
     request_->AddConnectionAttempts(socket_attempts);
   } else {
     request_->AddConnectionAttempts(connection_->connection_attempts());
   }
 }
 
 }  // namespace net