[TabManager] Move TabManager into chrome/browser/resource_coordinator.

chrome/browser/resource_coordinator/tab_manager_delegate_chromeos.cc

 // Copyright 2015 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/memory/tab_manager_delegate_chromeos.h"
+#include "chrome/browser/resource_coordinator/tab_manager_delegate_chromeos.h"
 
 #include <math.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/memory_pressure_monitor_chromeos.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_handle.h"  // kNullProcessHandle.
 #include "base/process/process_metrics.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/time/time.h"
 #include "chrome/browser/chromeos/arc/process/arc_process.h"
 #include "chrome/browser/chromeos/arc/process/arc_process_service.h"
 #include "chrome/browser/memory/memory_kills_monitor.h"
-#include "chrome/browser/memory/tab_stats.h"
+#include "chrome/browser/resource_coordinator/tab_stats.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_features.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
 #include "components/arc/arc_util.h"
 #include "components/device_event_log/device_event_log.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/zygote_host_linux.h"
 #include "ui/wm/public/activation_client.h"
 
 using base::ProcessHandle;
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 
-namespace memory {
+namespace resource_coordinator {
 namespace {
 
 // When switching to a new tab the tab's renderer's OOM score needs to be
 // updated to reflect its front-most status and protect it from discard.
 // However, doing this immediately might slow down tab switch time, so wait
 // a little while before doing the adjustment.
 const int kFocusedProcessScoreAdjustIntervalMs = 500;
 
 wm::ActivationClient* GetActivationClient() {
   if (!ash::Shell::HasInstance())
@@ skipping 32 matching lines @@
       return os << "BACKGROUND_APP";
     case ProcessType::UNKNOWN_TYPE:
       return os << "UNKNOWN_TYPE";
     default:
       return os << "NOT_IMPLEMENTED_ERROR";
   }
   return os;
 }
 
 // TabManagerDelegate::Candidate implementation.
-std::ostream& operator<<(
-    std::ostream& out, const TabManagerDelegate::Candidate& candidate) {
+std::ostream& operator<<(std::ostream& out,
+                         const TabManagerDelegate::Candidate& candidate) {
   if (candidate.app()) {
     out << "app " << *candidate.app();
   } else if (candidate.tab()) {
     const TabStats* const& tab = candidate.tab();
     out << "tab " << tab->title << ", renderer_handle: " << tab->renderer_handle
         << ", oom_score: " << tab->oom_score
         << ", is_discarded: " << tab->is_discarded
         << ", discard_count: " << tab->discard_count
         << ", last_active: " << tab->last_active;
   }
@@ skipping 87 matching lines @@
 
   // If a chrome tab.
   base::ProcessHandle pid_;
   // If an Android app.
   int nspid_;
 };
 
 // TabManagerDelegate::MemoryStat implementation.
 
 // static
-int TabManagerDelegate::MemoryStat::ReadIntFromFile(
-    const char* file_name, const int default_val) {
+int TabManagerDelegate::MemoryStat::ReadIntFromFile(const char* file_name,
+                                                    const int default_val) {
   std::string file_string;
   if (!base::ReadFileToString(base::FilePath(file_name), &file_string)) {
     LOG(WARNING) << "Unable to read file" << file_name;
     return default_val;
   }
   int val = default_val;
   if (!base::StringToInt(
-          base::TrimWhitespaceASCII(file_string, base::TRIM_TRAILING),
-          &val)) {
+          base::TrimWhitespaceASCII(file_string, base::TRIM_TRAILING), &val)) {
     LOG(WARNING) << "Unable to parse string" << file_string;
     return default_val;
   }
   return val;
 }
 
 // static
 int TabManagerDelegate::MemoryStat::LowMemoryMarginKB() {
   static const int kDefaultLowMemoryMarginMb = 50;
   static const char kLowMemoryMarginConfig[] =
       "/sys/kernel/mm/chromeos-low_mem/margin";
-  return ReadIntFromFile(
-      kLowMemoryMarginConfig, kDefaultLowMemoryMarginMb) * 1024;
+  return ReadIntFromFile(kLowMemoryMarginConfig, kDefaultLowMemoryMarginMb) *
+         1024;
 }
 
 // The logic of available memory calculation is copied from
 // _is_low_mem_situation() in kernel file include/linux/low-mem-notify.h.
 // Maybe we should let kernel report the number directly.
 int TabManagerDelegate::MemoryStat::TargetMemoryToFreeKB() {
   static const int kRamVsSwapWeight = 4;
   static const char kMinFilelistConfig[] = "/proc/sys/vm/min_filelist_kbytes";
   static const char kMinFreeKbytes[] = "/proc/sys/vm/min_free_kbytes";
 
   base::SystemMemoryInfoKB system_mem;
   base::GetSystemMemoryInfo(&system_mem);
   const int file_mem_kb = system_mem.active_file + system_mem.inactive_file;
   const int min_filelist_kb = ReadIntFromFile(kMinFilelistConfig, 0);
   const int min_free_kb = ReadIntFromFile(kMinFreeKbytes, 0);
   // Calculate current available memory in system.
   // File-backed memory should be easy to reclaim, unless they're dirty.
   // TODO(cylee): On ChromeOS, kernel reports low memory condition when
   // available memory is low. The following formula duplicates the logic in
   // kernel to calculate how much memory should be released. In the future,
   // kernel should try to report the amount of memory to release directly to
   // eliminate the duplication here.
-  const int available_mem_kb = system_mem.free +
-      file_mem_kb - system_mem.dirty - min_filelist_kb +
-      system_mem.swap_free / kRamVsSwapWeight -
-      min_free_kb;
+  const int available_mem_kb =
+      system_mem.free + file_mem_kb - system_mem.dirty - min_filelist_kb +
+      system_mem.swap_free / kRamVsSwapWeight - min_free_kb;
 
   return LowMemoryMarginKB() - available_mem_kb;
 }
 
 int TabManagerDelegate::MemoryStat::EstimatedMemoryFreedKB(
     base::ProcessHandle pid) {
   std::unique_ptr<base::ProcessMetrics> process_metrics(
       base::ProcessMetrics::CreateProcessMetrics(pid));
   base::WorkingSetKBytes mem_usage;
   process_metrics->GetWorkingSetKBytes(&mem_usage);
   return mem_usage.priv;
 }
 
 TabManagerDelegate::TabManagerDelegate(
     const base::WeakPtr<TabManager>& tab_manager)
-  : TabManagerDelegate(tab_manager, new MemoryStat()) {
-}
+    : TabManagerDelegate(tab_manager, new MemoryStat()) {}
 
 TabManagerDelegate::TabManagerDelegate(
     const base::WeakPtr<TabManager>& tab_manager,
     TabManagerDelegate::MemoryStat* mem_stat)
     : tab_manager_(tab_manager),
       focused_process_(new FocusedProcess()),
       mem_stat_(mem_stat),
       weak_ptr_factory_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllBrowserContextsAndSources());
@@ skipping 39 matching lines @@
     // window, so schedule an early adjustment for all processes to reflect
     // the change.
     // Put a dummy FocusedProcess with nspid = kInvalidArcAppNspid for now to
     // indicate the focused process is an arc app.
     // TODO(cylee): Fix it when we have nspid info in ARC windows.
     focused_process_->SetArcAppNspid(FocusedProcess::kInvalidArcAppNspid);
     // If the timer is already running (possibly for a tab), it'll be reset
     // here.
     focus_process_score_adjust_timer_.Start(
         FROM_HERE,
-        TimeDelta::FromMilliseconds(kFocusedProcessScoreAdjustIntervalMs),
-        this, &TabManagerDelegate::ScheduleEarlyOomPrioritiesAdjustment);
+        TimeDelta::FromMilliseconds(kFocusedProcessScoreAdjustIntervalMs), this,
+        &TabManagerDelegate::ScheduleEarlyOomPrioritiesAdjustment);
   }
   if (arc::IsArcAppWindow(lost_active)) {
     // Do not bother adjusting OOM score if the ARC window is deactivated
     // shortly.
     if (focused_process_->ResetIfIsArcApp() &&
         focus_process_score_adjust_timer_.IsRunning())
       focus_process_score_adjust_timer_.Stop();
   }
 }
 
 void TabManagerDelegate::ScheduleEarlyOomPrioritiesAdjustment() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (tab_manager_) {
     AdjustOomPriorities(tab_manager_->GetUnsortedTabStats());
   }
 }
 
 // If able to get the list of ARC procsses, prioritize tabs and apps as a whole.
 // Otherwise try to kill tabs only.
-void TabManagerDelegate::LowMemoryKill(
-    const TabStatsList& tab_list) {
+void TabManagerDelegate::LowMemoryKill(const TabStatsList& tab_list) {
   arc::ArcProcessService* arc_process_service = arc::ArcProcessService::Get();
   if (arc_process_service &&
       arc_process_service->RequestAppProcessList(
           base::Bind(&TabManagerDelegate::LowMemoryKillImpl,
                      weak_ptr_factory_.GetWeakPtr(), tab_list))) {
     // LowMemoryKillImpl will be called asynchronously so nothing left to do.
     return;
   }
   // If the list of ARC processes is not available, call LowMemoryKillImpl
   // synchronously with an empty list of apps.
@@ skipping 46 matching lines @@
                                  it->second != chrome::kLowestRendererOomScore);
 
   if (not_lowest_score) {
     // 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 there's an existing running timer (could be for ARC app), it
     // would be replaced by a new task.
     focus_process_score_adjust_timer_.Start(
         FROM_HERE,
-        TimeDelta::FromMilliseconds(kFocusedProcessScoreAdjustIntervalMs),
-        this, &TabManagerDelegate::OnFocusTabScoreAdjustmentTimeout);
+        TimeDelta::FromMilliseconds(kFocusedProcessScoreAdjustIntervalMs), this,
+        &TabManagerDelegate::OnFocusTabScoreAdjustmentTimeout);
   }
 }
 
 void TabManagerDelegate::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED:
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       content::RenderProcessHost* host =
@@ skipping 12 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();
+                .ptr()
+                ->GetProcess();
         AdjustFocusedTabScore(render_host->GetHandle());
       }
       // Do not handle the "else" case when it changes to invisible because
       // 1. The behavior is a bit awkward in that when switching from tab A to
       // tab B, the event "invisible of B" comes after "visible of A". It can
       // cause problems when the 2 tabs have the same content (e.g., New Tab
       // Page). To be more clear, if we try to cancel the timer when losing
       // focus it may cancel the timer for the same renderer process.
       // 2. When another window is launched on top of an existing browser
       // window, the selected tab in the existing browser didn't receive this
@@ skipping 72 matching lines @@
       arc_service_manager->arc_bridge_service()->process(), KillProcess);
   if (!arc_process_instance)
     return false;
 
   arc_process_instance->KillProcess(nspid, "LowMemoryKill");
   return true;
 }
 
 bool TabManagerDelegate::KillTab(int64_t tab_id) {
   // Check |tab_manager_| is alive before taking tabs into consideration.
-  return tab_manager_ &&
-      tab_manager_->CanDiscardTab(tab_id) &&
-      tab_manager_->DiscardTabById(tab_id);
+  return tab_manager_ && tab_manager_->CanDiscardTab(tab_id) &&
+         tab_manager_->DiscardTabById(tab_id);
 }
 
-
 chromeos::DebugDaemonClient* TabManagerDelegate::GetDebugDaemonClient() {
   return chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
 }
 
 void TabManagerDelegate::LowMemoryKillImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   VLOG(2) << "LowMemoryKillImpl";
 
@@ skipping 29 matching lines @@
       if (IsRecentlyKilledArcProcess(it->app()->process_name(), now)) {
         MEMORY_LOG(ERROR) << "Avoided killing " << it->app()->process_name()
                           << " too often";
         continue;
       }
       int estimated_memory_freed_kb =
           mem_stat_->EstimatedMemoryFreedKB(it->app()->pid());
       if (KillArcProcess(it->app()->nspid())) {
         recently_killed_arc_processes_[it->app()->process_name()] = now;
         target_memory_to_free_kb -= estimated_memory_freed_kb;
-        MemoryKillsMonitor::LogLowMemoryKill("APP", estimated_memory_freed_kb);
+        memory::MemoryKillsMonitor::LogLowMemoryKill("APP",
+                                                     estimated_memory_freed_kb);
         MEMORY_LOG(ERROR) << "Killed app " << it->app()->process_name() << " ("
                           << it->app()->pid() << ")"
                           << ", estimated " << estimated_memory_freed_kb
                           << " KB freed";
       } else {
         MEMORY_LOG(ERROR) << "Failed to kill " << it->app()->process_name();
       }
     } else {
       int64_t tab_id = it->tab()->tab_contents_id;
       // The estimation is problematic since multiple tabs may share the same
       // process, while the calculation counts memory used by the whole process.
       // So |estimated_memory_freed_kb| is an over-estimation.
       int estimated_memory_freed_kb =
           mem_stat_->EstimatedMemoryFreedKB(it->tab()->renderer_handle);
       if (KillTab(tab_id)) {
         target_memory_to_free_kb -= estimated_memory_freed_kb;
-        MemoryKillsMonitor::LogLowMemoryKill("TAB", estimated_memory_freed_kb);
+        memory::MemoryKillsMonitor::LogLowMemoryKill("TAB",
+                                                     estimated_memory_freed_kb);
         MEMORY_LOG(ERROR) << "Killed tab " << it->tab()->title << " ("
                           << it->tab()->renderer_handle << "), estimated "
                           << estimated_memory_freed_kb << " KB freed";
       }
     }
   }
   if (target_memory_to_free_kb > 0) {
     MEMORY_LOG(ERROR)
         << "Unable to kill enough candidates to meet target_memory_to_free_kb ";
   }
@@ skipping 118 matching lines @@
     // Need to update OOM score if the calculated score is different from
     // current cached score.
     if (oom_score_map_[pid] != score) {
       VLOG(3) << "Update OOM score " << score << " for " << *cur;
       oom_scores_to_change[pid] = static_cast<int32_t>(score);
     }
     priority += priority_increment;
   }
 
   if (oom_scores_to_change.size()) {
-    GetDebugDaemonClient()->SetOomScoreAdj(
-        oom_scores_to_change, base::Bind(&OnSetOomScoreAdj));
+    GetDebugDaemonClient()->SetOomScoreAdj(oom_scores_to_change,
+                                           base::Bind(&OnSetOomScoreAdj));
   }
 }
 
-}  // namespace memory
+}  // namespace resource_coordinator