Instrumenting internals of AccountIdFetcher::Start to locate the source of jankiness.

google_apis/gaia/oauth2_token_service.cc

 // Copyright 2013 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 "google_apis/gaia/oauth2_token_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 196 matching lines @@
     const OAuth2TokenService::ScopeSet& scopes,
     base::WeakPtr<RequestImpl> waiting_request) {
   OAuth2TokenService::Fetcher* fetcher = new Fetcher(
       oauth2_token_service,
       account_id,
       getter,
       client_id,
       client_secret,
       scopes,
       waiting_request);
+
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/422460 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422460 OAuth2TokenService::Fetcher::CreateAndStart"));
+
   fetcher->Start();
   return fetcher;
 }
 
 OAuth2TokenService::Fetcher::Fetcher(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
@@ skipping 177 matching lines @@
 }
 
 std::vector<std::string> OAuth2TokenService::GetAccounts() {
   return std::vector<std::string>();
 }
 
 scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/422460 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422460 OAuth2TokenService::StartRequest"));
+

[Roger Tawa OOO till Jul 10th, 2014/11/04 16:28:08]

I wonder if this trace is needed given that this function simply wraps
StartRequestForClientWithContext(), which is traced below.  Is there a reason to
trace this function and not the next two below?

[vadimt, 2014/11/04 16:47:53]

Done.

   return StartRequestForClientWithContext(
       account_id,
       GetRequestContext(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
       scopes,
       consumer);
 }
 
 scoped_ptr<OAuth2TokenService::Request>
@@ skipping 30 matching lines @@
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestForClientWithContext(
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
     const ScopeSet& scopes,
     Consumer* consumer) {
   DCHECK(CalledOnValidThread());
 
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/422460 is fixed.
+  tracked_objects::ScopedTracker tracking_profile1(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422460 OAuth2TokenService::StartRequestForClientWithContext 1"));
+
   scoped_ptr<RequestImpl> request(new RequestImpl(account_id, consumer));
   FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
                     OnAccessTokenRequested(account_id,
                                            consumer->id(),
                                            scopes));
 
   if (!RefreshTokenIsAvailable(account_id)) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/422460 is fixed.
+    tracked_objects::ScopedTracker tracking_profile2(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422460 OAuth2TokenService::StartRequestForClientWithContext 2"));
+
     GoogleServiceAuthError error(GoogleServiceAuthError::USER_NOT_SIGNED_UP);
 
     FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
                       OnFetchAccessTokenComplete(
                           account_id, consumer->id(), scopes, error,
                           base::Time()));
 
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &RequestImpl::InformConsumer,
         request->AsWeakPtr(),
         error,
         std::string(),
         base::Time()));
     return request.Pass();
   }
 
   RequestParameters request_parameters(client_id,
                                        account_id,
                                        scopes);
   if (HasCacheEntry(request_parameters)) {
+    // TODO(vadimt): Remove ScopedTracker below once crbug.com/422460 is fixed.
+    tracked_objects::ScopedTracker tracking_profile3(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422460 OAuth2TokenService::StartRequestForClientWithContext 3"));
+
     StartCacheLookupRequest(request.get(), request_parameters, consumer);
   } else {
     FetchOAuth2Token(request.get(),
                      account_id,
                      getter,
                      client_id,
                      client_secret,
                      scopes);
   }
   return request.Pass();
 }
 
 void OAuth2TokenService::FetchOAuth2Token(RequestImpl* request,
                                           const std::string& account_id,
                                           net::URLRequestContextGetter* getter,
                                           const std::string& client_id,
                                           const std::string& client_secret,
                                           const ScopeSet& scopes) {
+  // TODO(vadimt): Remove ScopedTracker below once crbug.com/422460 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422460 OAuth2TokenService::FetchOAuth2Token"));
+
   // If there is already a pending fetcher for |scopes| and |account_id|,
   // simply register this |request| for those results rather than starting
   // a new fetcher.
   RequestParameters request_parameters = RequestParameters(client_id,
                                                            account_id,
                                                            scopes);
   std::map<RequestParameters, Fetcher*>::iterator iter =
       pending_fetchers_.find(request_parameters);
   if (iter != pending_fetchers_.end()) {
     iter->second->AddWaitingRequest(request->AsWeakPtr());
@@ skipping 290 matching lines @@
     const std::string& account_id,
     const ScopeSet& scopes) const {
   PendingFetcherMap::const_iterator iter = pending_fetchers_.find(
       OAuth2TokenService::RequestParameters(
           client_id,
           account_id,
           scopes));
   return iter == pending_fetchers_.end() ?
              0 : iter->second->GetWaitingRequestCount();
 }