Further instrumentations to locate the jank source

net/http/http_cache_transaction.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_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 423 matching lines @@
     return ERR_UNEXPECTED;
 
   SetRequest(net_log, request);
 
   // We have to wait until the backend is initialized so we start the SM.
   next_state_ = STATE_GET_BACKEND;
   int rv = DoLoop(OK);
 
   // Setting this here allows us to check for the existence of a callback_ to
   // determine if we are still inside Start.
   if (rv == ERR_IO_PENDING)

[gavinp, 2014/12/03 01:17:13]

You need curly braces here now, see
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Conditionals .

(likewise elsewhere throughout this CL)

[vadimt, 2014/12/03 01:41:53]

Done.

-    callback_ = callback;
+    callback_ = tracked_objects::ScopedTracker::TrackCallback(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422516 HttpCache::Transaction::Start"),
+        callback);
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartIgnoringLastError(
     const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   int rv = RestartNetworkRequest();
 
   if (rv == ERR_IO_PENDING)
-    callback_ = callback;
+    callback_ = tracked_objects::ScopedTracker::TrackCallback(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422516 HttpCache::Transaction::RestartIgnoringLastError"),
+        callback);
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartWithCertificate(
     X509Certificate* client_cert,
     const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   int rv = RestartNetworkRequestWithCertificate(client_cert);
 
   if (rv == ERR_IO_PENDING)
-    callback_ = callback;
+    callback_ = tracked_objects::ScopedTracker::TrackCallback(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422516 HttpCache::Transaction::RestartWithCertificate"),
+        callback);
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartWithAuth(
     const AuthCredentials& credentials,
     const CompletionCallback& callback) {
   DCHECK(auth_response_.headers.get());
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   // Clear the intermediate response since we are going to start over.
   auth_response_ = HttpResponseInfo();
 
   int rv = RestartNetworkRequestWithAuth(credentials);
 
   if (rv == ERR_IO_PENDING)
-    callback_ = callback;
+    callback_ = tracked_objects::ScopedTracker::TrackCallback(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422516 HttpCache::Transaction::RestartWithAuth"),
+        callback);
 
   return rv;
 }
 
 bool HttpCache::Transaction::IsReadyToRestartForAuth() {
   if (!network_trans_.get())
     return false;
   return network_trans_->IsReadyToRestartForAuth();
 }
 
@@ skipping 37 matching lines @@
     case READ:
       rv = ReadFromEntry(buf, buf_len);
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
   }
 
   if (rv == ERR_IO_PENDING) {
     DCHECK(callback_.is_null());
-    callback_ = callback;
+    callback_ = tracked_objects::ScopedTracker::TrackCallback(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 HttpCache::Transaction::Read"),
+        callback);
   }
   return rv;
 }
 
 void HttpCache::Transaction::StopCaching() {
   // We really don't know where we are now. Hopefully there is no operation in
   // progress, but nothing really prevents this method to be called after we
   // returned ERR_IO_PENDING. We cannot attempt to truncate the entry at this
   // point because we need the state machine for that (and even if we are really
   // free, that would be an asynchronous operation). In other words, keep the
@@ skipping 118 matching lines @@
 
 int HttpCache::Transaction::ResumeNetworkStart() {
   if (network_trans_)
     return network_trans_->ResumeNetworkStart();
   return ERR_UNEXPECTED;
 }
 
 //-----------------------------------------------------------------------------
 
 void HttpCache::Transaction::DoCallback(int rv) {
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422516 HttpCache::Transaction::DoCallback"));
+
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(!callback_.is_null());
 
   read_buf_ = NULL;  // Release the buffer before invoking the callback.
 
   // Since Run may result in Read being called, clear callback_ up front.
   CompletionCallback c = callback_;
   callback_.Reset();
   c.Run(rv);
 }
@@ skipping 2216 matching lines @@
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 Transaction::OnIOComplete"));
 
   DoLoop(result);
 }
 
 }  // namespace net