Revert "Do not kill recently killed ARC processes again"

chrome/browser/memory/tab_manager_delegate_chromeos_unittest.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/memory/tab_manager_delegate_chromeos.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 84 matching lines @@
   // chrome app.
   EXPECT_EQ(500, candidates[6].tab()->tab_contents_id);
   // internal page.
   EXPECT_EQ(200, candidates[7].tab()->tab_contents_id);
   // background service.
   EXPECT_EQ("service", candidates[8].app()->process_name());
 }
 
 class MockTabManagerDelegate : public TabManagerDelegate {
  public:
-  MockTabManagerDelegate()
-      : TabManagerDelegate(nullptr),
-        always_return_true_from_is_recently_killed_(false) {}
+  MockTabManagerDelegate(): TabManagerDelegate(nullptr) {
+  }
 
   explicit MockTabManagerDelegate(TabManagerDelegate::MemoryStat* mem_stat)
-      : TabManagerDelegate(nullptr, mem_stat),
-        always_return_true_from_is_recently_killed_(false) {}
+      : TabManagerDelegate(nullptr, mem_stat) {
+  }
 
   // unit test.
   std::vector<int> GetKilledArcProcesses() {
     return killed_arc_processes_;
   }
 
   // unit test.
   std::vector<int64_t> GetKilledTabs() {
     return killed_tabs_;
   }
 
   // unit test.
   void Clear() {
     killed_arc_processes_.clear();
     killed_tabs_.clear();
   }
 
-  // unit test.
-  void set_always_return_true_from_is_recently_killed(
-      bool always_return_true_from_is_recently_killed) {
-    always_return_true_from_is_recently_killed_ =
-        always_return_true_from_is_recently_killed;
-  }
-
-  bool IsRecentlyKilledArcProcess(const std::string& process_name,
-                                  const base::TimeTicks& now) override {
-    if (always_return_true_from_is_recently_killed_)
-      return true;
-    return TabManagerDelegate::IsRecentlyKilledArcProcess(process_name, now);
-  }
-
  protected:
   bool KillArcProcess(const int nspid) override {
     killed_arc_processes_.push_back(nspid);
     return true;
   }
 
   bool KillTab(int64_t tab_id) override {
     killed_tabs_.push_back(tab_id);
     return true;
   }
 
   chromeos::DebugDaemonClient* GetDebugDaemonClient() override {
     return &debugd_client_;
   }
 
  private:
   chromeos::FakeDebugDaemonClient debugd_client_;
   std::vector<int> killed_arc_processes_;
   std::vector<int64_t> killed_tabs_;
-  bool always_return_true_from_is_recently_killed_;
 };
 
 class MockMemoryStat : public TabManagerDelegate::MemoryStat {
  public:
   MockMemoryStat() {}
   ~MockMemoryStat() override {}
 
   int TargetMemoryToFreeKB() override {
     return target_memory_to_free_kb_;
   }
@@ skipping 67 matching lines @@
   EXPECT_EQ(300, oom_score_map[10]);
   EXPECT_EQ(344, oom_score_map[20]);
   EXPECT_EQ(388, oom_score_map[40]);
   EXPECT_EQ(431, oom_score_map[12]);
   EXPECT_EQ(475, oom_score_map[11]);
 
   // Lower priority part.
   EXPECT_EQ(650, oom_score_map[30]);
 }
 
-TEST_F(TabManagerDelegateTest, IsRecentlyKilledArcProcess) {
-  constexpr char kProcessName1[] = "org.chromium.arc.test1";
-  constexpr char kProcessName2[] = "org.chromium.arc.test2";
-
-  // Not owned.
-  MockMemoryStat* memory_stat = new MockMemoryStat();
-  // Instantiate the mock instance.
-  MockTabManagerDelegate tab_manager_delegate(memory_stat);
-
-  // When the process name is not in the map, IsRecentlyKilledArcProcess should
-  // return false.
-  const base::TimeTicks now = base::TimeTicks::Now();
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName1, now));
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName2, now));
-
-  // Update the map to tell the manager that the process was killed very
-  // recently.
-  tab_manager_delegate.recently_killed_arc_processes_[kProcessName1] = now;
-  EXPECT_TRUE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName1, now));
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName2, now));
-  tab_manager_delegate.recently_killed_arc_processes_[kProcessName1] =
-      now - base::TimeDelta::FromMicroseconds(1);
-  EXPECT_TRUE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName1, now));
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName2, now));
-  tab_manager_delegate.recently_killed_arc_processes_[kProcessName1] =
-      now - TabManagerDelegate::GetArcRespawnKillDelay();
-  EXPECT_TRUE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName1, now));
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName2, now));
-
-  // Update the map to tell the manager that the process was killed
-  // (GetArcRespawnKillDelay() + 1) seconds ago. In this case,
-  // IsRecentlyKilledArcProcess(kProcessName1) should return false.
-  tab_manager_delegate.recently_killed_arc_processes_[kProcessName1] =
-      now - TabManagerDelegate::GetArcRespawnKillDelay() -
-      base::TimeDelta::FromSeconds(1);
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName1, now));
-  EXPECT_FALSE(
-      tab_manager_delegate.IsRecentlyKilledArcProcess(kProcessName2, now));
-}
-
-TEST_F(TabManagerDelegateTest, DoNotKillRecentlyKilledArcProcesses) {
-  // Not owned.
-  MockMemoryStat* memory_stat = new MockMemoryStat();
-
-  // Instantiate the mock instance.
-  MockTabManagerDelegate tab_manager_delegate(memory_stat);
-  tab_manager_delegate.set_always_return_true_from_is_recently_killed(true);
-
-  std::vector<arc::ArcProcess> arc_processes;
-  arc_processes.emplace_back(
-      1, 10, "service", arc::mojom::ProcessState::SERVICE, kNotFocused, 500);
-
-  memory_stat->SetTargetMemoryToFreeKB(250000);
-  memory_stat->SetProcessPss(30, 10000);
-  tab_manager_delegate.LowMemoryKillImpl({} /* tab_list */, arc_processes);
-
-  auto killed_arc_processes = tab_manager_delegate.GetKilledArcProcesses();
-  EXPECT_EQ(0U, killed_arc_processes.size());
-}
-
 TEST_F(TabManagerDelegateTest, KillMultipleProcesses) {
   // Not owned.
   MockMemoryStat* memory_stat = new MockMemoryStat();
 
   // Instantiate the mock instance.
   MockTabManagerDelegate tab_manager_delegate(memory_stat);
 
   std::vector<arc::ArcProcess> arc_processes;
   arc_processes.emplace_back(1, 10, "focused", arc::mojom::ProcessState::TOP,
                              kIsFocused, 100);
@@ skipping 62 matching lines @@
   ASSERT_EQ(2U, killed_arc_processes.size());
   EXPECT_EQ(3, killed_arc_processes[0]);
   EXPECT_EQ(5, killed_arc_processes[1]);
   // Killed tabs and their content id.
   // Note that process with pid 11 is counted twice. But so far I don't have a
   // good way to estimate the memory freed if multiple tabs share one process.
   ASSERT_EQ(3U, killed_tabs.size());
   EXPECT_EQ(2, killed_tabs[0]);
   EXPECT_EQ(5, killed_tabs[1]);
   EXPECT_EQ(1, killed_tabs[2]);
-
-  // Check that killed apps are in the map.
-  const TabManagerDelegate::KilledArcProcessesMap& processes_map =
-      tab_manager_delegate.recently_killed_arc_processes_;
-  EXPECT_EQ(2U, processes_map.size());
-  EXPECT_EQ(1U, processes_map.count("service"));
-  EXPECT_EQ(1U, processes_map.count("not-visible"));
 }
 
 }  // namespace memory