[chrome/browser/extensions] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/extensions/extension_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 "chrome/browser/extensions/extension_storage_monitor.h"
 
 #include <map>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 104 matching lines @@
   }
 
   // Register as an observer for the extension's storage events.
   void StartObservingForExtension(
       scoped_refptr<storage::QuotaManager> quota_manager,
       const std::string& extension_id,
       const GURL& site_url,
       int64 next_threshold,
       const base::TimeDelta& rate,
       bool should_uma) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(quota_manager.get());
 
     GURL origin = site_url.GetOrigin();
     StorageState& state = origin_state_map_[origin];
     state.quota_manager = quota_manager;
     state.extension_id = extension_id;
     state.next_threshold = next_threshold;
     state.should_uma = should_uma;
 
     // We always observe persistent storage usage.
     storage::StorageObserver::MonitorParams params(
         storage::kStorageTypePersistent, origin, rate, false);
     quota_manager->AddStorageObserver(this, params);
     if (should_uma) {
       // And if this is for uma, we also observe temporary storage usage.
       MonitorParams temporary_params(
           storage::kStorageTypeTemporary, origin, rate, false);
       quota_manager->AddStorageObserver(this, temporary_params);
     }
   }
 
   // Updates the threshold for an extension already being monitored.
   void UpdateThresholdForExtension(const std::string& extension_id,
                                    int64 next_threshold) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end();
          ++it) {
       if (it->second.extension_id == extension_id) {
         it->second.next_threshold = next_threshold;
         break;
       }
     }
   }
 
   // Deregister as an observer for the extension's storage events.
   void StopObservingForExtension(const std::string& extension_id) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end(); ) {
       if (it->second.extension_id == extension_id) {
         storage::StorageObserver::Filter filter(
             storage::kStorageTypePersistent, it->first);
         it->second.quota_manager->RemoveStorageObserverForFilter(this, filter);
         // We also need to unregister temporary storage observation, if this was
         // being tracked for uma.
         if (it->second.should_uma) {
           storage::StorageObserver::Filter temporary_filter(
               storage::kStorageTypeTemporary, it->first);
           it->second.quota_manager->RemoveStorageObserverForFilter(this,
                                                                    filter);
         }
         origin_state_map_.erase(it++);
       } else {
         ++it;
       }
     }
   }
 
   // Stop observing all storage events. Called during shutdown.
   void StopObserving() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end(); ++it) {
       it->second.quota_manager->RemoveStorageObserver(this);
     }
     origin_state_map_.clear();
   }
 
  private:
   friend class base::DeleteHelper<StorageEventObserver>;
@@ skipping 194 matching lines @@
   placeholders.push_back(context_->GetPath().BaseName().MaybeAsASCII());
   placeholders.push_back(extension_id);
 
   return ReplaceStringPlaceholders(kNotificationIdFormat, placeholders, NULL);
 }
 
 void ExtensionStorageMonitor::OnStorageThresholdExceeded(
     const std::string& extension_id,
     int64 next_threshold,
     int64 current_usage) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   const Extension* extension = GetExtensionById(context_, extension_id);
   if (!extension)
     return;
 
   if (GetNextStorageThreshold(extension->id()) < next_threshold)
     SetNextStorageThreshold(extension->id(), next_threshold);
 
   const int kIconSize = message_center::kNotificationIconSize;
   ExtensionResource resource =  IconsInfo::GetIconResource(
@@ skipping 263 matching lines @@
 void ExtensionStorageMonitor::SetStorageNotificationEnabled(
     const std::string& extension_id,
     bool enable_notifications) {
   extension_prefs_->UpdateExtensionPref(
       extension_id,
       kPrefDisableStorageNotifications,
       enable_notifications ? NULL : new base::FundamentalValue(true));
 }
 
 }  // namespace extensions