Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.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.
 //
 // GalleryWatchManager implementation.
 
 #include "chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.h"
 
 #include <list>
 #include <set>
@@ skipping 20 matching lines @@
 // Value: GalleryWatchManager*.
 // This map owns the GalleryWatchManager object.
 typedef std::map<void*, extensions::GalleryWatchManager*> WatchManagerMap;
 WatchManagerMap* g_gallery_watch_managers = NULL;
 
 // Dispatches the gallery changed event on the UI thread.
 void SendGalleryChangedEventOnUIThread(
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
     MediaGalleryPrefId gallery_id,
     const std::set<std::string>& extension_ids) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (event_router.get())
     event_router->OnGalleryChanged(gallery_id, extension_ids);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //            GalleryWatchManager::GalleryFilePathWatcher                    //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 75 matching lines @@
 GalleryWatchManager::GalleryFilePathWatcher::GalleryFilePathWatcher(
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
     MediaGalleryPrefId gallery_id,
     const base::FilePath& path,
     const std::string& extension_id,
     const base::Closure& on_destroyed_callback)
     : event_router_(event_router),
       gallery_id_(gallery_id),
       on_destroyed_callback_(on_destroyed_callback),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   gallery_path_ = path;
   AddExtension(extension_id);
 }
 
 void GalleryWatchManager::GalleryFilePathWatcher::AddExtension(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (ContainsKey(extension_watch_info_map_, extension_id))
     return;
   extension_watch_info_map_[extension_id] = base::Time();
   AddRef();
 }
 
 void GalleryWatchManager::GalleryFilePathWatcher::RemoveExtension(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (extension_watch_info_map_.erase(extension_id) == 1)
     Release();
 }
 
 void GalleryWatchManager::GalleryFilePathWatcher::OnExtensionUnloaded(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   RemoveExtensionReferences(extension_id);
 }
 
 bool GalleryWatchManager::GalleryFilePathWatcher::SetupWatch() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   return file_watcher_.Watch(
       gallery_path_, true,
       base::Bind(&GalleryFilePathWatcher::OnFilePathChanged,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GalleryWatchManager::GalleryFilePathWatcher::RemoveAllWatchReferences() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   std::set<std::string> extension_ids;
   for (ExtensionWatchInfoMap::iterator iter = extension_watch_info_map_.begin();
        iter != extension_watch_info_map_.end(); ++iter)
     extension_ids.insert(iter->first);
 
   for (std::set<std::string>::const_iterator it = extension_ids.begin();
        it != extension_ids.end(); ++it)
     RemoveExtensionReferences(*it);
 }
 
 GalleryWatchManager::GalleryFilePathWatcher::~GalleryFilePathWatcher() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   on_destroyed_callback_.Run();
 }
 
 void GalleryWatchManager::GalleryFilePathWatcher::OnFilePathChanged(
     const base::FilePath& path,
     bool error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (error || (path != gallery_path_))
     return;
 
   std::set<std::string> extension_ids;
   for (ExtensionWatchInfoMap::iterator iter = extension_watch_info_map_.begin();
        iter != extension_watch_info_map_.end(); ++iter) {
     if (!iter->second.is_null()) {
       // Ignore gallery change event if it is received too frequently.
       // For example, when an user copies/deletes 1000 media files from a
       // gallery, this callback is called 1000 times within a span of 10ms.
@@ skipping 10 matching lines @@
   if (!extension_ids.empty()) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(SendGalleryChangedEventOnUIThread, event_router_,
                    gallery_id_, extension_ids));
   }
 }
 
 void GalleryWatchManager::GalleryFilePathWatcher::RemoveExtensionReferences(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   ExtensionWatchInfoMap::iterator it =
       extension_watch_info_map_.find(extension_id);
   if (it == extension_watch_info_map_.end())
     return;
   extension_watch_info_map_.erase(it);
   Release();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //                       GalleryWatchManager                                 //
 ///////////////////////////////////////////////////////////////////////////////
 
 // static
 GalleryWatchManager* GalleryWatchManager::GetForProfile(
     void* profile_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(profile_id);
   bool has_watch_manager = (g_gallery_watch_managers &&
                             GalleryWatchManager::HasForProfile(profile_id));
   if (!g_gallery_watch_managers)
     g_gallery_watch_managers = new WatchManagerMap;
   if (!has_watch_manager)
     (*g_gallery_watch_managers)[profile_id] = new GalleryWatchManager;
   return (*g_gallery_watch_managers)[profile_id];
 }
 
 // static
 bool GalleryWatchManager::HasForProfile(void* profile_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(profile_id);
   if (!g_gallery_watch_managers)
     return false;
   WatchManagerMap::const_iterator it =
       g_gallery_watch_managers->find(profile_id);
   return (it != g_gallery_watch_managers->end());
 }
 
 // static
 void GalleryWatchManager::OnProfileShutdown(void* profile_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(profile_id);
   if (!g_gallery_watch_managers || g_gallery_watch_managers->empty())
     return;
   WatchManagerMap::iterator it = g_gallery_watch_managers->find(profile_id);
   if (it == g_gallery_watch_managers->end())
     return;
   delete it->second;
   g_gallery_watch_managers->erase(it);
   if (g_gallery_watch_managers->empty())
     delete g_gallery_watch_managers;
 }
 
 // static
 bool GalleryWatchManager::SetupGalleryWatch(
     void* profile_id,
     MediaGalleryPrefId gallery_id,
     const base::FilePath& watch_path,
     const std::string& extension_id,
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   return GalleryWatchManager::GetForProfile(profile_id)->StartGalleryWatch(
       gallery_id, watch_path, extension_id, event_router);
 }
 
 // static
 void GalleryWatchManager::RemoveGalleryWatch(void* profile_id,
                                              const base::FilePath& watch_path,
                                              const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (!GalleryWatchManager::HasForProfile(profile_id))
     return;
   GalleryWatchManager::GetForProfile(profile_id)->StopGalleryWatch(
       watch_path, extension_id);
 }
 
 void GalleryWatchManager::OnExtensionUnloaded(void* profile_id,
                                               const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (!GalleryWatchManager::HasForProfile(profile_id))
     return;
   GalleryWatchManager::GetForProfile(profile_id)->HandleExtensionUnloadedEvent(
       extension_id);
 }
 
 GalleryWatchManager::GalleryWatchManager() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 }
 
 GalleryWatchManager::~GalleryWatchManager() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DeleteAllWatchers();
 }
 
 bool GalleryWatchManager::StartGalleryWatch(
     MediaGalleryPrefId gallery_id,
     const base::FilePath& watch_path,
     const std::string& extension_id,
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   WatcherMap::const_iterator iter = gallery_watchers_.find(watch_path);
   if (iter != gallery_watchers_.end()) {
     // Already watched.
     iter->second->AddExtension(extension_id);
     return true;
   }
 
   // Need to add a new watcher.
   scoped_refptr<GalleryFilePathWatcher> watch(
       new GalleryFilePathWatcher(
           event_router, gallery_id, watch_path, extension_id,
           base::Bind(&GalleryWatchManager::RemoveGalleryFilePathWatcherEntry,
                      base::Unretained(this),
                      watch_path)));
   if (!watch->SetupWatch())
     return false;
   gallery_watchers_[watch_path] = watch.get();
   return true;
 }
 
 void GalleryWatchManager::StopGalleryWatch(
     const base::FilePath& watch_path,
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   WatcherMap::iterator iter = gallery_watchers_.find(watch_path);
   if (iter == gallery_watchers_.end())
     return;
   // Remove the renderer process for this watch.
   iter->second->RemoveExtension(extension_id);
 }
 
 void GalleryWatchManager::HandleExtensionUnloadedEvent(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   std::list<base::FilePath> watchers_to_notify;
   for (WatcherMap::iterator iter = gallery_watchers_.begin();
        iter != gallery_watchers_.end(); ++iter)
     watchers_to_notify.push_back(iter->first);
 
   for (std::list<base::FilePath>::const_iterator path =
            watchers_to_notify.begin();
        path != watchers_to_notify.end(); ++path) {
      WatcherMap::iterator iter = gallery_watchers_.find(*path);
      if (iter == gallery_watchers_.end())
        continue;
      iter->second->OnExtensionUnloaded(extension_id);
   }
 }
 
 void GalleryWatchManager::DeleteAllWatchers() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (gallery_watchers_.empty())
     return;
 
   // Create a copy of |gallery_watchers_| to delete because
   // GalleryFilePathWatcher::RemoveAllWatchReferences will
   // eventually call GalleryWatchManager::RemoveGalleryFilePathWatcherEntry()
   // and modify |gallery_watchers_|.
   WatcherMap watchers_to_delete(gallery_watchers_);
   for (WatcherMap::const_iterator iter = watchers_to_delete.begin();
        iter != watchers_to_delete.end(); ++iter)
     iter->second->RemoveAllWatchReferences();
 }
 
 void GalleryWatchManager::RemoveGalleryFilePathWatcherEntry(
     const base::FilePath& watch_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   gallery_watchers_.erase(watch_path);
 }
 
 }  // namespace extensions