[MemoryPressure] Move chrome/browser/chromeos/* to chrome/browser/memory/*.

chrome/browser/memory/oom_priority_manager_chromeos.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 "chrome/browser/memory/oom_priority_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "ash/multi_profile_uma.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/memory_pressure_monitor.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
-#include "chrome/browser/chromeos/memory/low_memory_observer.h"
-#include "chrome/browser/chromeos/memory/oom_memory_details.h"
-#include "chrome/browser/chromeos/memory/system_memory_stats_recorder.h"
+#include "chrome/browser/memory/low_memory_observer_chromeos.h"
+#include "chrome/browser/memory/oom_memory_details.h"
+#include "chrome/browser/memory/system_memory_stats_recorder.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/zygote_host_linux.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 using content::WebContents;
 
-namespace chromeos {
-
+namespace memory {
 namespace {
 
 // The default interval in seconds after which to adjust the oom_score_adj
 // value.
 const int kAdjustmentIntervalSeconds = 10;
 
 // For each period of this length we record a statistic to indicate whether
 // or not the user experienced a low memory event. If you change this interval
 // you must replace Tabs.Discard.DiscardInLastMinute with a new statistic.
 const int kRecentTabDiscardIntervalSeconds = 60;
@@ skipping 13 matching lines @@
 int64 IdFromWebContents(WebContents* web_contents) {
   return reinterpret_cast<int64>(web_contents);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // OomPriorityManager
 
 OomPriorityManager::TabStats::TabStats()
-  : is_app(false),
-    is_reloadable_ui(false),
-    is_playing_audio(false),
-    is_pinned(false),
-    is_selected(false),
-    is_discarded(false),
-    renderer_handle(0),
-    tab_contents_id(0) {
+    : is_app(false),
+      is_reloadable_ui(false),
+      is_playing_audio(false),
+      is_pinned(false),
+      is_selected(false),
+      is_discarded(false),
+      renderer_handle(0),
+      tab_contents_id(0) {
 }
 
 OomPriorityManager::TabStats::~TabStats() {
 }
 
 OomPriorityManager::OomPriorityManager()
     : focused_tab_process_info_(std::make_pair(0, 0)),
       discard_count_(0),
       recent_tab_discard_(false) {
   // Use the old |LowMemoryObserver| when there is no |MemoryPressureMonitor|.
   if (!base::MemoryPressureMonitor::Get())
     low_memory_observer_.reset(new LowMemoryObserver);
 
-  registrar_.Add(this,
-      content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
-      content::NotificationService::AllBrowserContextsAndSources());
-  registrar_.Add(this,
-      content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-      content::NotificationService::AllBrowserContextsAndSources());
-  registrar_.Add(this,
-      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+                 content::NotificationService::AllBrowserContextsAndSources());
 }
 
 OomPriorityManager::~OomPriorityManager() {
   Stop();
 }
 
 void OomPriorityManager::Start() {
   if (!timer_.IsRunning()) {
-    timer_.Start(FROM_HERE,
-                 TimeDelta::FromSeconds(kAdjustmentIntervalSeconds),
-                 this,
-                 &OomPriorityManager::AdjustOomPriorities);
+    timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kAdjustmentIntervalSeconds),
+                 this, &OomPriorityManager::AdjustOomPriorities);
   }
   if (!recent_tab_discard_timer_.IsRunning()) {
     recent_tab_discard_timer_.Start(
-        FROM_HERE,
-        TimeDelta::FromSeconds(kRecentTabDiscardIntervalSeconds),
-        this,
-        &OomPriorityManager::RecordRecentTabDiscard);
+        FROM_HERE, TimeDelta::FromSeconds(kRecentTabDiscardIntervalSeconds),
+        this, &OomPriorityManager::RecordRecentTabDiscard);
   }
   start_time_ = TimeTicks::Now();
   // If a |LowMemoryObserver| exists we use the old system, otherwise we create
   // a |MemoryPressureListener| to listen for memory events.
   if (low_memory_observer_) {
     low_memory_observer_->Start();
   } else {
     base::MemoryPressureMonitor* monitor = base::MemoryPressureMonitor::Get();
     if (monitor) {
-      memory_pressure_listener_.reset(new base::MemoryPressureListener(
-          base::Bind(&OomPriorityManager::OnMemoryPressure,
-                     base::Unretained(this))));
+      memory_pressure_listener_.reset(
+          new base::MemoryPressureListener(base::Bind(
+              &OomPriorityManager::OnMemoryPressure, base::Unretained(this))));
       base::MemoryPressureListener::MemoryPressureLevel level =
           monitor->GetCurrentPressureLevel();
       if (level ==
           base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
         OnMemoryPressure(level);
       }
     }
   }
 }
 
 void OomPriorityManager::Stop() {
   timer_.Stop();
   recent_tab_discard_timer_.Stop();
   if (low_memory_observer_)
     low_memory_observer_->Stop();
   else
     memory_pressure_listener_.reset();
 }
 
 std::vector<base::string16> OomPriorityManager::GetTabTitles() {
   TabStatsList stats = GetTabStatsOnUIThread();
   base::AutoLock oom_score_autolock(oom_score_lock_);
   std::vector<base::string16> titles;
   titles.reserve(stats.size());
   TabStatsList::iterator it = stats.begin();
-  for ( ; it != stats.end(); ++it) {
+  for (; it != stats.end(); ++it) {
     base::string16 str;
     str.reserve(4096);
     int score = oom_score_map_[it->child_process_host_id];
     str += base::IntToString16(score);
     str += base::ASCIIToUTF16(" - ");
     str += it->title;
     str += base::ASCIIToUTF16(it->is_app ? " app" : "");
     str += base::ASCIIToUTF16(it->is_reloadable_ui ? " reloadable_ui" : "");
     str += base::ASCIIToUTF16(it->is_playing_audio ? " playing_audio" : "");
     str += base::ASCIIToUTF16(it->is_pinned ? " pinned" : "");
     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_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) {
+       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() {
   LogMemory("Tab Discards Memory details",
             base::Bind(&OomPriorityManager::PurgeMemoryAndDiscardTabs));
@@ skipping 25 matching lines @@
   // are likely to have open. Most of the benefit is the from NTP URL.
   const char* const kReloadableUrlPrefixes[] = {
       chrome::kChromeUIDownloadsURL,
       chrome::kChromeUIHistoryURL,
       chrome::kChromeUINewTabURL,
       chrome::kChromeUISettingsURL,
   };
   // Prefix-match against the table above. Use strncmp to avoid allocating
   // memory to convert the URL prefix constants into std::strings.
   for (size_t i = 0; i < arraysize(kReloadableUrlPrefixes); ++i) {
-    if (!strncmp(url.spec().c_str(),
-                 kReloadableUrlPrefixes[i],
+    if (!strncmp(url.spec().c_str(), kReloadableUrlPrefixes[i],
                  strlen(kReloadableUrlPrefixes[i])))
       return true;
   }
   return false;
 }
 
 bool OomPriorityManager::DiscardTabById(int64 target_web_contents_id) {
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     TabStripModel* model = browser->tab_strip_model();
     for (int idx = 0; idx < model->count(); idx++) {
       // Can't discard tabs that are already discarded or active.
       if (model->IsTabDiscarded(idx) || (model->active_index() == idx))
         continue;
       WebContents* web_contents = model->GetWebContentsAt(idx);
       int64 web_contents_id = IdFromWebContents(web_contents);
       if (web_contents_id == target_web_contents_id) {
-        LOG(WARNING) << "Discarding tab " << idx
-                     << " id " << target_web_contents_id;
+        LOG(WARNING) << "Discarding tab " << idx << " id "
+                     << target_web_contents_id;
         // Record statistics before discarding because we want to capture the
         // memory state that lead to the discard.
         RecordDiscardStatistics();
         model->DiscardWebContentsAt(idx);
         recent_tab_discard_ = true;
         return true;
       }
     }
   }
   return false;
 }
 
 void OomPriorityManager::RecordDiscardStatistics() {
   // Record a raw count so we can compare to discard reloads.
   discard_count_++;
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Tabs.Discard.DiscardCount", discard_count_, 1, 1000, 50);
+  UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.Discard.DiscardCount", discard_count_, 1,
+                              1000, 50);
 
   // TODO(jamescook): Maybe incorporate extension count?
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Tabs.Discard.TabCount", GetTabCount(), 1, 100, 50);
+  UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.Discard.TabCount", GetTabCount(), 1, 100,
+                              50);
   // Record the discarded tab in relation to the amount of simultaneously
   // logged in users.
-  ash::MultiProfileUMA::RecordDiscardedTab(
-      ash::Shell::GetInstance()->session_state_delegate()->
-          NumberOfLoggedInUsers());
+  ash::MultiProfileUMA::RecordDiscardedTab(ash::Shell::GetInstance()
+                                               ->session_state_delegate()
+                                               ->NumberOfLoggedInUsers());
 
   // TODO(jamescook): If the time stats prove too noisy, then divide up users
   // based on how heavily they use Chrome using tab count as a proxy.
   // Bin into <= 1, <= 2, <= 4, <= 8, etc.
   if (last_discard_time_.is_null()) {
     // This is the first discard this session.
     TimeDelta interval = TimeTicks::Now() - start_time_;
     int interval_seconds = static_cast<int>(interval.InSeconds());
     // Record time in seconds over an interval of approximately 1 day.
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "Tabs.Discard.InitialTime2", interval_seconds, 1, 100000, 50);
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.Discard.InitialTime2", interval_seconds,
+                                1, 100000, 50);
   } else {
     // Not the first discard, so compute time since last discard.
     TimeDelta interval = TimeTicks::Now() - last_discard_time_;
     int interval_ms = static_cast<int>(interval.InMilliseconds());
     // Record time in milliseconds over an interval of approximately 1 day.
     // Start at 100 ms to get extra resolution in the target 750 ms range.
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "Tabs.Discard.IntervalTime2", interval_ms, 100, 100000 * 1000, 50);
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.Discard.IntervalTime2", interval_ms, 100,
+                                100000 * 1000, 50);
   }
   // Record chromeos's concept of system memory usage at the time of the
   // discard.
   RecordMemoryStats(RECORD_MEMORY_STATS_TAB_DISCARDED);
 
   // Set up to record the next interval.
   last_discard_time_ = TimeTicks::Now();
 }
 
 void OomPriorityManager::RecordRecentTabDiscard() {
@@ skipping 22 matching lines @@
 
 int OomPriorityManager::GetTabCount() const {
   int tab_count = 0;
   for (chrome::BrowserIterator it; !it.done(); it.Next())
     tab_count += it->tab_strip_model()->count();
   return tab_count;
 }
 
 // Returns true if |first| is considered less desirable to be killed
 // than |second|.
-bool OomPriorityManager::CompareTabStats(TabStats first,
-                                         TabStats second) {
+bool OomPriorityManager::CompareTabStats(TabStats first, TabStats second) {
   // Being currently selected is most important to protect.
   if (first.is_selected != second.is_selected)
     return first.is_selected;
 
   // Tab with internal web UI like NTP or Settings are good choices to discard,
   // so protect non-Web UI and let the other conditionals finish the sort.
   if (first.is_reloadable_ui != second.is_reloadable_ui)
     return !first.is_reloadable_ui;
 
   // Being pinned is important to protect.
@@ skipping 61 matching lines @@
             base::chromeos::MemoryPressureMonitor::Get();
         if (monitor)
           monitor->ScheduleEarlyCheck();
       }
       break;
     }
     case content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED: {
       bool visible = *content::Details<bool>(details).ptr();
       if (visible) {
         content::RenderProcessHost* render_host =
-            content::Source<content::RenderWidgetHost>(source).ptr()->
-            GetProcess();
-        focused_tab_process_info_ = std::make_pair(render_host->GetID(),
-                                                   render_host->GetHandle());
+            content::Source<content::RenderWidgetHost>(source)
+                .ptr()
+                ->GetProcess();
+        focused_tab_process_info_ =
+            std::make_pair(render_host->GetID(), render_host->GetHandle());
 
         // If the currently focused tab already has a lower score, do not
         // set it. This can happen in case the newly focused tab is script
         // connected to the previous tab.
         ProcessScoreMap::iterator it;
         it = oom_score_map_.find(focused_tab_process_info_.first);
-        if (it == oom_score_map_.end()
-            || it->second != chrome::kLowestRendererOomScore) {
+        if (it == oom_score_map_.end() ||
+            it->second != chrome::kLowestRendererOomScore) {
           // By starting a timer we guarantee that the tab is focused for
           // certain amount of time. Secondly, it also does not add overhead
           // to the tab switching time.
           if (focus_tab_score_adjust_timer_.IsRunning())
             focus_tab_score_adjust_timer_.Reset();
           else
-            focus_tab_score_adjust_timer_.Start(FROM_HERE,
-              TimeDelta::FromMilliseconds(kFocusedTabScoreAdjustIntervalMs),
-              this, &OomPriorityManager::OnFocusTabScoreAdjustmentTimeout);
+            focus_tab_score_adjust_timer_.Start(
+                FROM_HERE,
+                TimeDelta::FromMilliseconds(kFocusedTabScoreAdjustIntervalMs),
+                this, &OomPriorityManager::OnFocusTabScoreAdjustmentTimeout);
         }
       }
       break;
     }
     default:
       NOTREACHED() << L"Received unexpected notification";
       break;
   }
 }
 
@@ skipping 67 matching lines @@
     browser_active = false;
   }
   // Sort the data we collected so that least desirable to be
   // killed is first, most desirable is last.
   std::sort(stats_list.begin(), stats_list.end(), CompareTabStats);
   return stats_list;
 }
 
 // static
 std::vector<OomPriorityManager::ProcessInfo>
-    OomPriorityManager::GetChildProcessInfos(
-    const TabStatsList& stats_list) {
+OomPriorityManager::GetChildProcessInfos(const TabStatsList& stats_list) {
   std::vector<ProcessInfo> process_infos;
   std::set<base::ProcessHandle> already_seen;
   for (TabStatsList::const_iterator iterator = stats_list.begin();
        iterator != stats_list.end(); ++iterator) {
     // stats_list contains entries for already-discarded tabs. If the PID
     // (renderer_handle) is zero, we don't need to adjust the oom_score.
     if (iterator->renderer_handle == 0)
       continue;
 
     bool inserted = already_seen.insert(iterator->renderer_handle).second;
     if (!inserted) {
       // We've already seen this process handle.
       continue;
     }
 
-    process_infos.push_back(std::make_pair(
-        iterator->child_process_host_id, iterator->renderer_handle));
+    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_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).
   // oom_score_adj takes values from -1000 to 1000.  Negative values
   // are reserved for system processes, and we want to give some room
   // below the range we're using to allow for things that want to be
   // above the renderers in priority, so the defined range gives us
   // some variation in priority without taking up the whole range.  In
   // the end, however, it's a pretty arbitrary range to use.  Higher
   // values are more likely to be killed by the OOM killer.
   float priority = chrome::kLowestRendererOomScore;
-  const int kPriorityRange = chrome::kHighestRendererOomScore -
-                             chrome::kLowestRendererOomScore;
+  const int kPriorityRange =
+      chrome::kHighestRendererOomScore - chrome::kLowestRendererOomScore;
   float priority_increment =
       static_cast<float>(kPriorityRange) / process_infos.size();
   for (const auto& process_info : process_infos) {
     int score = static_cast<int>(priority + 0.5f);
-    ProcessScoreMap::iterator it =
-        oom_score_map_.find(process_info.first);
+    ProcessScoreMap::iterator it = oom_score_map_.find(process_info.first);
     // If a process has the same score as the newly calculated value,
     // do not set it.
     if (it == oom_score_map_.end() || it->second != score) {
       content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(
           process_info.second, score);
       oom_score_map_[process_info.first] = score;
     }
     priority += priority_increment;
   }
 }
 
 void OomPriorityManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   // 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
+}  // namespace memory