Add trace to the caller of QuotaManager::GetAvailableSpace

content/browser/appcache/appcache_storage_impl.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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/trace_event/trace_event.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
@@ skipping 625 matching lines @@
 
   if (!quota_manager) {
     if (storage_->service()->special_storage_policy() &&
         storage_->service()->special_storage_policy()->IsStorageUnlimited(
             group_record_.origin))
       space_available_ = kint64max;
     Schedule();
     return;
   }
 
+  // crbug.com/349708
+  TRACE_EVENT0(
+      "io",
+      "AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule");
+
   // We have to ask the quota manager for the value.
   storage_->pending_quota_queries_.insert(this);
   quota_manager->GetUsageAndQuota(
       group_record_.origin,
       storage::kStorageTypeTemporary,
       base::Bind(&StoreGroupAndCacheTask::OnQuotaCallback, this));
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::OnQuotaCallback(

[michaeln, 2015/10/09 00:51:42]

If i understand the trace properly, the time is being spent in completion
callbacks rather than in the quotamgr proper. I think tracing methods like this
OnQuotaCallback method are the more interesting ones to trace.

We want to trace anything reachable thru DidGetAvailableSpace(). Given how the
quotamgr works (aggregates completion of multiple internal tasks to finally
complete an external callers request), i think the completion routines of most
async quotamgr api calls are reachable.

[oshima, 2015/10/09 17:14:09]

That's the theory. I was adding the caller side as some calls are simply
providing callback.
Because QuotaManager calls the callback on IO thread, this can identify which
path is blocking IO.

I added the trace to the callback side where makes sense though.

     storage::QuotaStatusCode status,
     int64 usage,
     int64 quota) {
   if (storage_) {
     if (status == storage::kQuotaStatusOk)
       space_available_ = std::max(static_cast<int64>(0), quota - usage);
     else
       space_available_ = 0;
     storage_->pending_quota_queries_.erase(this);
     Schedule();
@@ skipping 1287 matching lines @@
 
 void AppCacheStorageImpl::OnLazyCommitTimer() {
   lazy_commit_timer_.Stop();
   if (is_disabled())
     return;
   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
   task->Schedule();
 }
 
 }  // namespace content