Don't kill a process if it has IMPORTANT_FOREGROUND or higher priority

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 227 matching lines @@
   // 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);
   arc_processes.emplace_back(2, 20, "visible1", arc::mojom::ProcessState::TOP,
                              kNotFocused, 200);
   arc_processes.emplace_back(
       3, 30, "service", arc::mojom::ProcessState::SERVICE, kNotFocused, 500);
-  arc_processes.emplace_back(4, 40, "visible2", arc::mojom::ProcessState::TOP,
+  arc_processes.emplace_back(4, 40, "visible2",
+                             arc::mojom::ProcessState::IMPORTANT_FOREGROUND,
                              kNotFocused, 150);
+  arc_processes.emplace_back(5, 50, "not-visible",
+                             arc::mojom::ProcessState::IMPORTANT_BACKGROUND,
+                             kNotFocused, 300);
 
   TabStats tab1, tab2, tab3, tab4, tab5;
   tab1.is_pinned = true;
   tab1.renderer_handle = 11;
   tab1.tab_contents_id = 1;
 
   tab2.is_internal_page = true;
   tab2.renderer_handle = 11;
   tab2.tab_contents_id = 2;
 
@@ skipping 13 matching lines @@
 
   // Sorted order:
   // app "focused"     pid: 10  nspid 1
   // app "visible1"    pid: 20  nspid 2
   // app "visible2"    pid: 40  nspid 4
   // tab3              pid: 12  tab_contents_id 3
   // tab4              pid: 12  tab_contents_id 4
   // tab1              pid: 11  tab_contents_id 1
   // tab5              pid: 12  tab_contents_id 5
   // tab2              pid: 11  tab_contents_id 2
+  // app "not-visible" pid: 50  nspid 5
   // app "service"     pid: 30  nspid 3
   memory_stat->SetTargetMemoryToFreeKB(250000);
   // Entities to be killed.
   memory_stat->SetProcessPss(30, 10000);
+  memory_stat->SetProcessPss(50, 5000);
   memory_stat->SetProcessPss(11, 200000);
   memory_stat->SetProcessPss(12, 30000);
   // Should not be used.
   memory_stat->SetProcessPss(40, 50000);
   memory_stat->SetProcessPss(20, 30000);
   memory_stat->SetProcessPss(10, 100000);
 
   tab_manager_delegate.LowMemoryKillImpl(tab_list, arc_processes);
 
   auto killed_arc_processes = tab_manager_delegate.GetKilledArcProcesses();
   auto killed_tabs = tab_manager_delegate.GetKilledTabs();
 
   // Killed apps and their nspid.
-  EXPECT_EQ(1U, killed_arc_processes.size());
+  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.
-  EXPECT_EQ(3U, killed_tabs.size());
+  ASSERT_EQ(3U, killed_tabs.size());
   EXPECT_EQ(2, killed_tabs[0]);
   EXPECT_EQ(5, killed_tabs[1]);
   EXPECT_EQ(1, killed_tabs[2]);
 }
 
 }  // namespace memory