Add trace to the caller of QuotaManager::GetAvailableSpace

storage/browser/quota/storage_monitor.cc

 // Copyright 2014 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 "storage/browser/quota/storage_monitor.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
+#include "base/trace_event/trace_event.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/common/quota/quota_status_code.h"
 
 namespace storage {
 
 // StorageObserverList:
 
 StorageObserverList::ObserverState::ObserverState()
     : requires_update(false) {
@@ skipping 20 matching lines @@
 
 void StorageObserverList::OnStorageChange(const StorageObserver::Event& event) {
   for (StorageObserverStateMap::iterator it = observers_.begin();
        it != observers_.end(); ++it) {
     it->second.requires_update = true;
   }
 
   MaybeDispatchEvent(event);
 }
 
 void StorageObserverList::MaybeDispatchEvent(

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

and this

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

Done.

     const StorageObserver::Event& event) {
   notification_timer_.Stop();
   base::TimeDelta min_delay = base::TimeDelta::Max();
   bool all_observers_notified = true;
 
   for (StorageObserverStateMap::iterator it = observers_.begin();
        it != observers_.end(); ++it) {
     if (!it->second.requires_update)
       continue;
 
     base::TimeTicks current_time = base::TimeTicks::Now();
     base::TimeDelta delta = current_time - it->second.last_notification_time;
     if (it->second.last_notification_time.is_null() ||
         delta >= it->second.rate) {
       it->second.requires_update = false;
       it->second.last_notification_time = current_time;
 
       if (it->second.origin == event.filter.origin) {
         it->first->OnStorageEvent(event);
       } else {
         // When the quota and usage of an origin is requested, QuotaManager
         // returns the quota and usage of the host. Multiple origins can map to
         // to the same host, so ensure the |origin| field in the dispatched
         // event matches the |origin| specified by the observer when it was
         // registered.
         StorageObserver::Event dispatch_event(event);
         dispatch_event.filter.origin = it->second.origin;
         it->first->OnStorageEvent(dispatch_event);

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

and these

       }
     } else {
       all_observers_notified = false;
       base::TimeDelta delay = it->second.rate - delta;
       if (delay < min_delay)
         min_delay = delay;
     }
   }
 
   // We need to respect the notification rate specified by observers. So if it
@@ skipping 87 matching lines @@
     return;
   }
 
   StartInitialization(filter);
 }
 
 void HostStorageObservers::StartInitialization(
     const StorageObserver::Filter& filter) {
   if (initialized_ || initializing_)
     return;
+  // crbug.com/349708
+  TRACE_EVENT0("io", "HostStorageObservers::StartInitialization");
 
   initializing_ = true;
   quota_manager_->GetUsageAndQuotaForWebApps(
       filter.origin,
       filter.storage_type,
       base::Bind(&HostStorageObservers::GotHostUsageAndQuota,
                  weak_factory_.GetWeakPtr(),
                  filter));
 }
 
 void HostStorageObservers::GotHostUsageAndQuota(

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

trace this

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

I added trace in OnStorageChange and MaybeDispatchEvent instead.

     const StorageObserver::Filter& filter,
     QuotaStatusCode status,
     int64 usage,
     int64 quota) {
   initializing_ = false;
   if (status != kQuotaStatusOk)
     return;
 
   initialized_ = true;
   cached_quota_ = quota;
   cached_usage_ = usage + usage_deltas_during_init_;
   DispatchEvent(filter, event_occurred_before_init_);
 }
 
 void HostStorageObservers::DispatchEvent(
     const StorageObserver::Filter& filter, bool is_update) {
   StorageObserver::Event event(filter,
                                std::max<int64>(cached_usage_, 0),
                                std::max<int64>(cached_quota_, 0));
   if (is_update)
     observers_.OnStorageChange(event);

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

and these

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

ditto

   else
     observers_.MaybeDispatchEvent(event);
 }
 
 
 // StorageTypeObservers:
 
 StorageTypeObservers::StorageTypeObservers(QuotaManager* quota_manager)
     : quota_manager_(quota_manager) {
 }
@@ skipping 142 matching lines @@
 
   StorageTypeObserversMap::iterator it =
       storage_type_observers_map_.find(filter.storage_type);
   if (it == storage_type_observers_map_.end())
     return;
 
   it->second->NotifyUsageChange(filter, delta);
 }
 
 }  // namespace storage