Add trace to the caller of QuotaManager::GetAvailableSpace

content/browser/quota_dispatcher_host.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 "content/browser/quota_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/trace_event/trace_event.h"
 #include "content/common/quota_messages.h"
 #include "content/public/browser/quota_permission_context.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "url/gurl.h"
 
 using storage::QuotaClient;
 using storage::QuotaManager;
 using storage::QuotaStatusCode;
 using storage::StorageType;
@@ skipping 44 matching lines @@
     : public RequestDispatcher {
  public:
   QueryUsageAndQuotaDispatcher(
       base::WeakPtr<QuotaDispatcherHost> dispatcher_host,
       int request_id)
       : RequestDispatcher(dispatcher_host, request_id),
         weak_factory_(this) {}
   ~QueryUsageAndQuotaDispatcher() override {}
 
   void QueryStorageUsageAndQuota(const GURL& origin, StorageType type) {
+    // crbug.com/349708
+    TRACE_EVENT0("io",
+                 "QuotaDispatcherHost::QueryUsageAndQuotaDispatcher"
+                 "::QueryStorageUsageAndQuota");
+
     quota_manager()->GetUsageAndQuotaForWebApps(
         origin, type,
         base::Bind(&QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
  private:
   void DidQueryStorageUsageAndQuota(
       QuotaStatusCode status, int64 usage, int64 quota) {
     if (!dispatcher_host())
       return;
+    // crbug.com/349708
+    TRACE_EVENT0("io", "QuotaDispatcherHost::RequestQuotaDispatcher"
+                 "::DidQueryStorageUsageAndQuota");
+
     if (status != storage::kQuotaStatusOk) {
       dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidQueryStorageUsageAndQuota(
           request_id(), usage, quota));
     }
     Completed();
   }
 
   base::WeakPtrFactory<QueryUsageAndQuotaDispatcher> weak_factory_;
@@ skipping 14 matching lines @@
         weak_factory_(this) {
     // Convert the requested size from uint64 to int64 since the quota backend
     // requires int64 values.
     // TODO(nhiroki): The backend should accept uint64 values.
     requested_quota_ = base::saturated_cast<int64>(params_.requested_size);
   }
   ~RequestQuotaDispatcher() override {}
 
   void Start() {
     DCHECK(dispatcher_host());
+    // crbug.com/349708
+    TRACE_EVENT0("io", "QuotaDispatcherHost::RequestQuotaDispatcher::Start");
 
     DCHECK(params_.storage_type == storage::kStorageTypeTemporary ||
            params_.storage_type == storage::kStorageTypePersistent);
     if (params_.storage_type == storage::kStorageTypePersistent) {
       quota_manager()->GetUsageAndQuotaForWebApps(
           params_.origin_url, params_.storage_type,
           base::Bind(&self_type::DidGetPersistentUsageAndQuota,
                      weak_factory_.GetWeakPtr()));
     } else {
       quota_manager()->GetUsageAndQuotaForWebApps(
@@ skipping 123 matching lines @@
     return;
   }
 
   RequestQuotaDispatcher* dispatcher =
       new RequestQuotaDispatcher(weak_factory_.GetWeakPtr(),
                                  params);
   dispatcher->Start();
 }
 
 }  // namespace content