Do not kill recently killed ARC processes again

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 <stdint.h>
 
 #include <algorithm>
 #include <map>
-#include <string>
 #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.
@@ skipping 22 matching lines @@
 #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/aura/window.h"
 #include "ui/wm/public/activation_client.h"
 
 using base::ProcessHandle;
 using base::TimeDelta;
+using base::TimeTicks;
 using content::BrowserThread;
 
 namespace memory {
 namespace {
 
 const char kExoShellSurfaceWindowName[] = "ExoShellSurface";
 const char kArcProcessNamePrefix[] = "org.chromium.arc.";
 
 // 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.
@@ skipping 21 matching lines @@
 }
 
 void OnSetOomScoreAdj(bool success, const std::string& output) {
   VLOG(2) << "OnSetOomScoreAdj " << success << " " << output;
   if (!success || output != "")
     LOG(WARNING) << "Set OOM score error: " << output;
 }
 
 }  // namespace
 
+// static
+const int64_t TabManagerDelegate::kArcSkipKillingTimeInSeconds = 60;
+
 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";
@@ skipping 440 matching lines @@
     }
     candidates.emplace_back(&app);
   }
 
   // Sort candidates according to priority.
   std::sort(candidates.begin(), candidates.end());
 
   return candidates;
 }
 
+bool TabManagerDelegate::IsRecentlyKilledArcProcess(
+    const std::string& process_name,
+    const TimeTicks& now) {
+  static constexpr TimeDelta kArcSkipKillingTime =
+      TimeDelta::FromSeconds(kArcSkipKillingTimeInSeconds);
+
+  auto it = recently_killed_arc_processes_.find(process_name);

[Luis Héctor Chávez, 2017/05/02 20:16:27]

nit: maybe const auto.

[Yusuke Sato, 2017/05/02 20:47:32]

Done.

+  if (it == recently_killed_arc_processes_.end())
+    return false;
+  return (now - it->second) <= kArcSkipKillingTime;
+}
+
 bool TabManagerDelegate::KillArcProcess(const int nspid) {
   auto* arc_service_manager = arc::ArcServiceManager::Get();
   if (!arc_service_manager)
     return false;
 
   auto* arc_process_instance = ARC_GET_INSTANCE_FOR_METHOD(
       arc_service_manager->arc_bridge_service()->process(), KillProcess);
   if (!arc_process_instance)
     return false;
 
@@ skipping 16 matching lines @@
 void TabManagerDelegate::LowMemoryKillImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   VLOG(2) << "LowMemoryKillImpl";
 
   const std::vector<TabManagerDelegate::Candidate> candidates =
       GetSortedCandidates(tab_list, arc_processes);
 
   int target_memory_to_free_kb = mem_stat_->TargetMemoryToFreeKB();
+  const TimeTicks now = TimeTicks::Now();
 
   // 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) {
     MEMORY_LOG(ERROR) << "Target memory to free: " << target_memory_to_free_kb
                       << " KB";
     if (target_memory_to_free_kb <= 0)
       break;
     // Never kill selected tab or Android foreground app, regardless whether
     // they're in the active window. Since the user experience would be bad.
     ProcessType process_type = it->process_type();
     if (process_type == ProcessType::VISIBLE_APP ||
         process_type == ProcessType::FOCUSED_APP ||
         process_type == ProcessType::FOCUSED_TAB) {
       MEMORY_LOG(ERROR) << "Skipped killing " << *it;
       continue;
     }
     if (it->app()) {
+      if (IsRecentlyKilledArcProcess(it->app()->process_name(), now)) {
+        MEMORY_LOG(ERROR) << "Avoided killing " << *it << " 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_LOG(ERROR) << "Killed " << *it << ", estimated "
                           << estimated_memory_freed_kb << " KB freed";
       } else {
         MEMORY_LOG(ERROR) << "Failed to kill " << *it;
       }
     } else {
       int64_t tab_id = it->tab()->tab_contents_id;
       // The estimation is problematic since multiple tabs may share the same
@@ skipping 112 matching lines @@
     }
     priority += priority_increment;
   }
 
   if (oom_scores_to_change.size())
     GetDebugDaemonClient()->SetOomScoreAdj(
         oom_scores_to_change, base::Bind(&OnSetOomScoreAdj));
 }
 
 }  // namespace memory