TabManagerDelegate: Better prioritize ARC processes.

chrome/browser/memory/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 <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 58 matching lines @@
 
 // Checks if a window renders ARC apps.
 bool IsArcWindow(aura::Window* window) {
   if (!window || window->name() != kExoShellSurfaceWindowName)
     return false;
   std::string application_id = exo::ShellSurface::GetApplicationId(window);
   return base::StartsWith(application_id, kArcProcessNamePrefix,
                           base::CompareCase::SENSITIVE);
 }
 
-bool IsArcWindowInForeground() {
-  auto activation_client = GetActivationClient();
-  return activation_client && IsArcWindow(activation_client->GetActiveWindow());
-}
-
-int AppStateToPriority(
-    const arc::mojom::ProcessState& process_state) {
-  // Logic copied from Android:
-  // frameworks/base/core/java/android/app/ActivityManager.java
-  // Note that ProcessState enumerates from most important (lower value) to
-  // least important (higher value), while ProcessPriority enumerates the
-  // opposite.
-  if (process_state >= arc::mojom::ProcessState::HOME) {
-    return ProcessPriority::ANDROID_BACKGROUND;
-  } else if (process_state >= arc::mojom::ProcessState::SERVICE) {
-    return ProcessPriority::ANDROID_SERVICE;
-  } else if (process_state >= arc::mojom::ProcessState::HEAVY_WEIGHT) {
-    return ProcessPriority::ANDROID_CANT_SAVE_STATE;
-  } else if (process_state >= arc::mojom::ProcessState::IMPORTANT_BACKGROUND) {
-    return ProcessPriority::ANDROID_PERCEPTIBLE;
-  } else if (process_state >= arc::mojom::ProcessState::IMPORTANT_FOREGROUND) {
-    return ProcessPriority::ANDROID_VISIBLE;
-  } else if (process_state >= arc::mojom::ProcessState::TOP_SLEEPING) {
-    return ProcessPriority::ANDROID_TOP_SLEEPING;
-  } else if (process_state >= arc::mojom::ProcessState::FOREGROUND_SERVICE) {
-    return ProcessPriority::ANDROID_FOREGROUND_SERVICE;
-  } else if (process_state >= arc::mojom::ProcessState::TOP) {
-    return IsArcWindowInForeground() ?
-        ProcessPriority::ANDROID_TOP :
-        ProcessPriority::ANDROID_TOP_INACTIVE;
-  } else if (process_state >= arc::mojom::ProcessState::PERSISTENT) {
-    return ProcessPriority::ANDROID_PERSISTENT;
-  }
-  return ProcessPriority::ANDROID_NON_EXISTS;
-}
-
-int TabStatsToPriority(const TabStats& tab) {
-  if (tab.is_selected)
-    return ProcessPriority::CHROME_SELECTED;
-
-  int priority = 0;
-
-  if (tab.is_app) {
-    priority = ProcessPriority::CHROME_APP;
-  } else if (tab.is_internal_page) {
-    priority = ProcessPriority::CHROME_INTERNAL;
-  } else {
-    priority = ProcessPriority::CHROME_NORMAL;
-  }
-  if (tab.is_pinned)
-    priority |= ProcessPriority::CHROME_PINNED;
-  if (tab.is_media)
-    priority |= ProcessPriority::CHROME_MEDIA;
-  if (tab.has_form_entry)
-    priority |= ProcessPriority::CHROME_CANT_SAVE_STATE;
-
-  return priority;
-}
-
 bool IsArcMemoryManagementEnabled() {
   return base::FeatureList::IsEnabled(features::kArcMemoryManagement);
 }
 
 }  // namespace
 
+std::ostream& operator<<(std::ostream& os, const ProcessType& type) {
+  switch (type) {
+    case ProcessType::FOCUSED_APP:
+      return os << "FOCUSED_APP/FOCUSED_TAB";
+    case ProcessType::VISIBLE_APP:
+      return os << "VISIBLE_APP";
+    case ProcessType::BACKGROUND_APP:
+      return os << "BACKGROUND_APP";
+    case ProcessType::BACKGROUND_TAB:
+      return os << "BACKGROUND_TAB";
+    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) {
-  if (candidate.is_arc_app) {
-    out << "app " << candidate.app->pid()
-        << " (" << candidate.app->process_name() << ")";
-  } else {
-    out << "tab " << candidate.tab->renderer_handle;
+  if (candidate.app()) {
+    out << "app " << candidate.app()->pid() << " ("
+        << candidate.app()->process_name() << ")"
+        << ", process_state " << candidate.app()->process_state()
+        << ", is_focused " << candidate.app()->is_focused()
+        << ", lastActivityTime " << candidate.app()->last_activity_time();
+  } else if (candidate.tab()) {
+    out << "tab " << candidate.tab()->renderer_handle;
   }
-  out << " with priority " << candidate.priority;
+  out << ", process_type " << candidate.process_type();
   return out;
 }
 
+TabManagerDelegate::Candidate& TabManagerDelegate::Candidate::operator=(
+    TabManagerDelegate::Candidate&& other) {
+  tab_ = other.tab_;
+  app_ = other.app_;
+  process_type_ = other.process_type_;
+  return *this;
+}
+
+bool TabManagerDelegate::Candidate::operator<(
+    const TabManagerDelegate::Candidate& rhs) const {
+  if (process_type() != rhs.process_type())
+    return process_type() < rhs.process_type();
+  if (app() && rhs.app())
+    return *app() < *rhs.app();
+  if (tab() && rhs.tab())
+    return TabManager::CompareTabStats(*tab(), *rhs.tab());
+  // Impossible case. If app and tab are mixed in one process type, favor
+  // apps.
+  NOTREACHED() << "Undefined comparison between apps and tabs";
+  return app();
+}
+
+ProcessType TabManagerDelegate::Candidate::GetProcessTypeInternal() const {
+  if (app()) {
+    if (app()->is_focused())
+      return ProcessType::FOCUSED_APP;
+    if (app()->process_state() == arc::mojom::ProcessState::TOP)
+      return ProcessType::VISIBLE_APP;
+    return ProcessType::BACKGROUND_APP;
+  }
+  if (tab()) {
+    if (tab()->is_selected)
+      return ProcessType::FOCUSED_TAB;
+    return ProcessType::BACKGROUND_TAB;
+  }
+  NOTREACHED() << "Unexpected process type";
+  return ProcessType::UNKNOWN_TYPE;
+}
+
 // Holds the info of a newly focused tab or app window. The focused process is
 // set to highest priority (lowest OOM score), but not immediately. To avoid
 // redundant settings the OOM score adjusting only happens after a timeout. If
 // the process loses focus before the timeout, the adjustment is canceled.
 //
 // This information might be set on UI thread and looked up on FILE thread. So a
 // lock is needed to avoid racing.
 class TabManagerDelegate::FocusedProcess {
  public:
   static const int kInvalidArcAppNspid = 0;
@@ skipping 232 matching lines @@
   }
   VLOG(2) << "Disable LowMemoryKiller";
   arc_process_instance_->DisableLowMemoryKiller();
 }
 
 void TabManagerDelegate::OnInstanceClosed() {
   arc_process_instance_ = nullptr;
   arc_process_instance_version_ = 0;
 }
 
+// TODO(cylee): Remove this function if Android process OOM score settings
+// is moved back to Android.
+// For example, negotiate non-overlapping OOM score ranges so Chrome and Android
+// can set OOM score for processes in their own world.
 void TabManagerDelegate::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (IsArcWindow(gained_active)) {
     // Currently there is no way to know which app is displayed in the ARC
     // 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.
@@ skipping 173 matching lines @@
             base::Bind(&TabManagerDelegate::AdjustOomPrioritiesImpl,
                        weak_ptr_factory_.GetWeakPtr(), tab_list))) {
       return;
     }
   }
   // Pass in a dummy list if unable to get ARC processes.
   AdjustOomPrioritiesImpl(tab_list, std::vector<arc::ArcProcess>());
 }
 
 // Excludes persistent ARC apps, but still preserves active chrome tabs and
-// top ARC apps. The latter ones should not be killed by TabManager since
-// we still want to adjust their oom_score_adj.
+// focused ARC apps. The latter ones should not be killed by TabManager here,
+// but we want to adjust their oom_score_adj.
 // static
 std::vector<TabManagerDelegate::Candidate>
 TabManagerDelegate::GetSortedCandidates(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
+  static constexpr char kAppLauncherProcessName[] =
+      "org.chromium.arc.applauncher";
 
   std::vector<Candidate> candidates;
   candidates.reserve(tab_list.size() + arc_processes.size());
 
   for (const auto& tab : tab_list) {
-    candidates.push_back(Candidate(&tab, TabStatsToPriority(tab)));
+    candidates.emplace_back(&tab);
   }
 
   for (const auto& app : arc_processes) {
-    Candidate candidate(&app, AppStateToPriority(app.process_state()));
-    // Skip persistent android processes since we should never kill them.
-    // Also don't ajust OOM score so their score remains min oom_score_adj.
-    if (candidate.priority >= ProcessPriority::ANDROID_PERSISTENT)
+    // Skip persistent android processes since they should never be killed here.
+    // Neither do we set their OOM scores so their score remains minimum.
+    //
+    // AppLauncher is treated specially in ARC++. For example it is taken
+    // as the dummy foreground app from Android's point of view when the focused
+    // window is not an Android app. We prefer never kill it.
+    if (app.process_state() <= arc::mojom::ProcessState::PERSISTENT_UI ||
+        app.process_name() == kAppLauncherProcessName)
       continue;
-    candidates.push_back(candidate);
+    candidates.emplace_back(&app);
   }
 
   // Sort candidates according to priority.
-  // TODO(cylee): Missing LRU property. Fix it when apps has the information.
   std::sort(candidates.begin(), candidates.end());
 
   return candidates;
 }
 
 bool TabManagerDelegate::KillArcProcess(const int nspid) {
   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);
 }
 
 void TabManagerDelegate::LowMemoryKillImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
 
   VLOG(2) << "LowMemoryKilleImpl";
-  std::vector<TabManagerDelegate::Candidate> candidates =
+  const std::vector<TabManagerDelegate::Candidate> candidates =
       GetSortedCandidates(tab_list, arc_processes);
 
   int target_memory_to_free_kb = mem_stat_->TargetMemoryToFreeKB();
-  for (const auto& entry : candidates) {
+  // Kill processes until the estimated amount of freed memory is sufficient to
+  // bring the system memory back to a normal level.
+  // The list is sorted by descending importance, so we go through the list
+  // backwards.
+  for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
     VLOG(3) << "Target memory to free: " << target_memory_to_free_kb << " KB";
     // Never kill selected tab or Android foreground app, regardless whether
     // they're in the active window. Since the user experience would be bad.
-    if ((!entry.is_arc_app &&
-         entry.priority >= ProcessPriority::CHROME_SELECTED) ||
-        (entry.is_arc_app &&
-         entry.priority >= ProcessPriority::ANDROID_TOP_INACTIVE)) {
-      VLOG(2) << "Skipped killing " << entry;
+    ProcessType process_type = it->process_type();
+    if (process_type == ProcessType::VISIBLE_APP ||
+        process_type == ProcessType::FOCUSED_APP ||
+        process_type == ProcessType::FOCUSED_TAB) {
+      VLOG(2) << "Skipped killing " << *it;
       continue;
     }
-    if (entry.is_arc_app) {
-        int estimated_memory_freed_kb =
-            mem_stat_->EstimatedMemoryFreedKB(entry.app->pid());
-        if (KillArcProcess(entry.app->nspid())) {
-          target_memory_to_free_kb -= estimated_memory_freed_kb;
-          uma_->ReportKill(estimated_memory_freed_kb);
-          VLOG(2) << "Killed " << entry;
-        }
+    if (it->app()) {
+      int estimated_memory_freed_kb =
+          mem_stat_->EstimatedMemoryFreedKB(it->app()->pid());
+      if (KillArcProcess(it->app()->nspid())) {
+        target_memory_to_free_kb -= estimated_memory_freed_kb;
+        uma_->ReportKill(estimated_memory_freed_kb);
+        VLOG(2) << "Killed " << *it;
+      }
     } else {
-      int64_t tab_id = entry.tab->tab_contents_id;
+      int64_t tab_id = it->tab()->tab_contents_id;
       int estimated_memory_freed_kb =
-          mem_stat_->EstimatedMemoryFreedKB(entry.tab->renderer_handle);
+          mem_stat_->EstimatedMemoryFreedKB(it->tab()->renderer_handle);
       if (KillTab(tab_id)) {
         target_memory_to_free_kb -= estimated_memory_freed_kb;
         uma_->ReportKill(estimated_memory_freed_kb);
-        VLOG(2) << "Killed " << entry;
+        VLOG(2) << "Killed " << *it;
       }
     }
     if (target_memory_to_free_kb < 0)
       break;
   }
 }
 
 void TabManagerDelegate::AdjustOomPrioritiesImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
   // Least important first.
-  auto candidates = GetSortedCandidates(tab_list, arc_processes);
+  const auto candidates = GetSortedCandidates(tab_list, arc_processes);
 
   // 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.
 
   // Break the processes into 2 parts. This is to help lower the chance of
   // altering OOM score for many processes on any small change.
   int range_middle =
       (chrome::kLowestRendererOomScore + chrome::kHighestRendererOomScore) / 2;
 
   // Find some pivot point. For now processes with priority >= CHROME_INTERNAL
   // are prone to be affected by LRU change. Taking them as "high priority"
   // processes.
-  auto lower_priority_part = candidates.rend();
-  // Iterate in reverse order since the list is sorted by least importance.
-  for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
-    if (it->priority < ProcessPriority::CHROME_INTERNAL) {
+  auto lower_priority_part = candidates.end();
+  for (auto it = candidates.begin(); it != candidates.end(); ++it) {
+    if (it->process_type() >= ProcessType::BACKGROUND_APP) {
       lower_priority_part = it;
       break;
     }
   }
 
   ProcessScoreMap new_map;
 
   // Higher priority part.
-  DistributeOomScoreInRange(candidates.rbegin(), lower_priority_part,
+  DistributeOomScoreInRange(candidates.begin(), lower_priority_part,
                             chrome::kLowestRendererOomScore, range_middle,
                             &new_map);
   // Lower priority part.
-  DistributeOomScoreInRange(lower_priority_part, candidates.rend(),
-                            range_middle, chrome::kHighestRendererOomScore,
-                            &new_map);
+  DistributeOomScoreInRange(lower_priority_part, candidates.end(), range_middle,
+                            chrome::kHighestRendererOomScore, &new_map);
   base::AutoLock oom_score_autolock(oom_score_lock_);
   oom_score_map_.swap(new_map);
 }
 
 void TabManagerDelegate::SetOomScoreAdjForApp(int nspid, int score) {
   if (!arc_process_instance_)
     return;
   if (arc_process_instance_version_ < 2) {
     VLOG(1) << "ProcessInstance version < 2 does not "
                "support SetOomScoreAdj() yet.";
@@ skipping 13 matching lines @@
 void TabManagerDelegate::SetOomScoreAdjForTabsOnFileThread(
     const std::vector<std::pair<base::ProcessHandle, int>>& entries) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   for (const auto& entry : entries) {
     content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(entry.first,
                                                                entry.second);
   }
 }
 
 void TabManagerDelegate::DistributeOomScoreInRange(
-    std::vector<TabManagerDelegate::Candidate>::reverse_iterator rbegin,
-    std::vector<TabManagerDelegate::Candidate>::reverse_iterator rend,
+    std::vector<TabManagerDelegate::Candidate>::const_iterator begin,
+    std::vector<TabManagerDelegate::Candidate>::const_iterator end,
     int range_begin,
     int range_end,
     ProcessScoreMap* new_map) {
   // OOM score setting for tabs involves file system operation so should be
   // done on file thread.
   std::vector<std::pair<base::ProcessHandle, int>> oom_score_for_tabs;
 
   // Though there might be duplicate process handles, it doesn't matter to
   // overestimate the number of processes here since the we don't need to
   // use up the full range.
-  int num = (rend - rbegin);
+  int num = (end - begin);
   const float priority_increment =
       static_cast<float>(range_end - range_begin) / num;
 
   float priority = range_begin;
-  for (auto cur = rbegin; cur != rend; ++cur) {
+  for (auto cur = begin; cur != end; ++cur) {
     int score = static_cast<int>(priority + 0.5f);
-    if (cur->is_arc_app) {
+    if (cur->app()) {
       // Use pid as map keys so it's globally unique.
-      (*new_map)[cur->app->pid()] = score;
+      (*new_map)[cur->app()->pid()] = score;
       int cur_app_pid_score = 0;
       {
         base::AutoLock oom_score_autolock(oom_score_lock_);
-        cur_app_pid_score = oom_score_map_[cur->app->pid()];
+        cur_app_pid_score = oom_score_map_[cur->app()->pid()];
       }
       if (cur_app_pid_score != score) {
         VLOG(3) << "Set OOM score " << score << " for " << *cur;
-        SetOomScoreAdjForApp(cur->app->nspid(), score);
+        SetOomScoreAdjForApp(cur->app()->nspid(), score);
       }
     } else {
-      base::ProcessHandle process_handle = cur->tab->renderer_handle;
+      base::ProcessHandle process_handle = cur->tab()->renderer_handle;
       // 1. tab_list contains entries for already-discarded tabs. If the PID
       // (renderer_handle) is zero, we don't need to adjust the oom_score.
       // 2. Only add unseen process handle so if there's multiple tab maps to
       // the same process, the process is set to an OOM score based on its "most
       // important" tab.
       if (process_handle != 0 &&
           new_map->find(process_handle) == new_map->end()) {
         (*new_map)[process_handle] = score;
         int process_handle_score = 0;
         {
           base::AutoLock oom_score_autolock(oom_score_lock_);
           process_handle_score = oom_score_map_[process_handle];
         }
         if (process_handle_score != score) {
           oom_score_for_tabs.push_back(std::make_pair(process_handle, score));
           VLOG(3) << "Set OOM score " << score << " for " << *cur;
         }
       } else {
         continue;  // Skip priority increment.
       }
     }
     priority += priority_increment;
   }
 
   if (oom_score_for_tabs.size())
     SetOomScoreAdjForTabs(oom_score_for_tabs);
 }
 
 }  // namespace memory