favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/chromeos/

chrome/browser/chromeos/memory/oom_priority_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.
 
 #include "chrome/browser/chromeos/memory/oom_priority_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 255 matching lines @@
     str += base::ASCIIToUTF16(it->is_discarded ? " discarded" : "");
     titles.push_back(str);
   }
   return titles;
 }
 
 // TODO(jamescook): This should consider tabs with references to other tabs,
 // such as tabs created with JavaScript window.open().  We might want to
 // discard the entire set together, or use that in the priority computation.
 bool OomPriorityManager::DiscardTab() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats = GetTabStatsOnUIThread();
   if (stats.empty())
     return false;
   // Loop until we find a non-discarded tab to kill.
   for (TabStatsList::const_reverse_iterator stats_rit = stats.rbegin();
        stats_rit != stats.rend();
        ++stats_rit) {
     int64 least_important_tab_id = stats_rit->tab_contents_id;
     if (DiscardTabById(least_important_tab_id))
       return true;
   }
   return false;
 }
 
 void OomPriorityManager::LogMemoryAndDiscardTab() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Deletes itself upon completion.
   OomMemoryDetails* details = new OomMemoryDetails();
   details->StartFetch(MemoryDetails::FROM_CHROME_ONLY);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OomPriorityManager, private:
 
 // static
 bool OomPriorityManager::IsReloadableUI(const GURL& url) {
@@ skipping 106 matching lines @@
 
     int mem_available_mb =
         (memory.active_file + memory.inactive_file + memory.free) / 1024;
     UMA_HISTOGRAM_MEGABYTES("Tabs.Discard.MemAvailableMB", mem_available_mb);
   }
   // Set up to record the next interval.
   last_discard_time_ = TimeTicks::Now();
 }
 
 void OomPriorityManager::RecordRecentTabDiscard() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If we change the interval we need to change the histogram name.
   UMA_HISTOGRAM_BOOLEAN("Tabs.Discard.DiscardInLastMinute",
                         recent_tab_discard_);
   // Reset for the next interval.
   recent_tab_discard_ = false;
 }
 
 void OomPriorityManager::PurgeBrowserMemory() {
   // Based on experimental evidence, attempts to free memory from renderers
   // have been too slow to use in OOM situations (V8 garbage collection) or
@@ skipping 47 matching lines @@
   // sudden_termination_allowed false, and that covers too many common pages
   // with ad networks and statistics scripts.  Ideally we would like to check
   // for beforeUnload handlers, which are likely to present a dialog asking
   // if the user wants to discard state.  crbug.com/123049
 
   // Being more recently active is more important.
   return first.last_active > second.last_active;
 }
 
 void OomPriorityManager::AdjustFocusedTabScoreOnFileThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   base::AutoLock oom_score_autolock(oom_score_lock_);
   base::ProcessHandle pid = focused_tab_process_info_.second;
   content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(
       pid, chrome::kLowestRendererOomScore);
   oom_score_map_[focused_tab_process_info_.first] =
       chrome::kLowestRendererOomScore;
 }
 
 void OomPriorityManager::OnFocusTabScoreAdjustmentTimeout() {
   BrowserThread::PostTask(
@@ skipping 91 matching lines @@
   last_adjust_time_ = TimeTicks::Now();
 
   TabStatsList stats_list = GetTabStatsOnUIThread();
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&OomPriorityManager::AdjustOomPrioritiesOnFileThread,
                  base::Unretained(this), stats_list));
 }
 
 OomPriorityManager::TabStatsList OomPriorityManager::GetTabStatsOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats_list;
   stats_list.reserve(32);  // 99% of users have < 30 tabs open
   bool browser_active = true;
   const BrowserList* ash_browser_list =
       BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
   for (BrowserList::const_reverse_iterator browser_iterator =
            ash_browser_list->begin_last_active();
        browser_iterator != ash_browser_list->end_last_active();
        ++browser_iterator) {
     Browser* browser = *browser_iterator;
@@ skipping 47 matching lines @@
     }
 
     process_infos.push_back(std::make_pair(
         iterator->child_process_host_id, iterator->renderer_handle));
   }
   return process_infos;
 }
 
 void OomPriorityManager::AdjustOomPrioritiesOnFileThread(
     TabStatsList stats_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   base::AutoLock oom_score_autolock(oom_score_lock_);
 
   // Remove any duplicate PIDs. Order of the list is maintained, so each
   // renderer process will take on the oom_score_adj of the most important
   // (least likely to be killed) tab.
   std::vector<ProcessInfo> process_infos = GetChildProcessInfos(stats_list);
 
   // Now we assign priorities based on the sorted list.  We're
   // assigning priorities in the range of kLowestRendererOomScore to
   // kHighestRendererOomScore (defined in chrome_constants.h).
@@ skipping 29 matching lines @@
   // For the moment we only do something when we reach a critical state.
   if (memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     LogMemoryAndDiscardTab();
   }
   // TODO(skuhne): If more memory pressure levels are introduced, we might
   // consider to call PurgeBrowserMemory() before CRITICAL is reached.
 }
 
 }  // namespace chromeos