Refactor ARC OOM handler code

chrome/browser/chromeos/arc/process/arc_process_unittest.cc

 // Copyright 2017 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/chromeos/arc/process/arc_process.h"
 
 #include <assert.h>
 #include <list>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace arc {
 
 namespace {
 
 // Tests that ArcProcess objects can be sorted by their priority (higher to
 // lower). This is critical for the OOM handler to work correctly.
 TEST(ArcProcess, TestSorting) {
   constexpr int64_t kNow = 1234567890;
 
   std::list<ArcProcess> processes;  // use list<> for emplace_front.
   processes.emplace_back(0, 0, "process 0", mojom::ProcessState::PERSISTENT,
-                         false /* is_foreground */, kNow + 1);
+                         false /* is_focused */, kNow + 1);

[Yusuke Sato, 2017/05/09 22:54:35]

fixed a typo, sorry.

   processes.emplace_front(1, 1, "process 1", mojom::ProcessState::PERSISTENT,
                           false, kNow);
   processes.emplace_back(2, 2, "process 2", mojom::ProcessState::LAST_ACTIVITY,
                          false, kNow);
   processes.emplace_front(3, 3, "process 3", mojom::ProcessState::LAST_ACTIVITY,
                           false, kNow + 1);
   processes.emplace_back(4, 4, "process 4", mojom::ProcessState::CACHED_EMPTY,
                          false, kNow + 1);
   processes.emplace_front(5, 5, "process 5", mojom::ProcessState::CACHED_EMPTY,
                           false, kNow);
@@ skipping 16 matching lines @@
   EXPECT_EQ(3, it->pid());
   ++it;
   EXPECT_EQ(2, it->pid());
   ++it;
   // Same, 4 should have higher priority.
   EXPECT_EQ(4, it->pid());
   ++it;
   EXPECT_EQ(5, it->pid());
 }
 
+TEST(ArcProcess, TestIsUserVisible) {
+  constexpr bool kIsFocused = false;
+
+  // Processes up to IMPORTANT_FOREGROUND are considered visible.
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::PERSISTENT,
+                         kIsFocused, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::PERSISTENT_UI,
+                         kIsFocused, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::TOP, true, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::TOP, false, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::BOUND_FOREGROUND_SERVICE,
+                         kIsFocused, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::FOREGROUND_SERVICE, kIsFocused, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::TOP_SLEEPING,
+                         kIsFocused, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::IMPORTANT_FOREGROUND, kIsFocused,
+                         0)
+                  .IsUserVisible());
+
+  // Others are non-visible.
+  EXPECT_FALSE(ArcProcess(0, 0, "process",
+                          mojom::ProcessState::IMPORTANT_BACKGROUND, kIsFocused,
+                          0)
+                   .IsUserVisible());
+  EXPECT_FALSE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::BACKUP, kIsFocused, 0)
+          .IsUserVisible());
+  EXPECT_FALSE(ArcProcess(0, 0, "process", mojom::ProcessState::HEAVY_WEIGHT,
+                          kIsFocused, 0)
+                   .IsUserVisible());
+  EXPECT_FALSE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::SERVICE, kIsFocused, 0)
+          .IsUserVisible());
+  EXPECT_FALSE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::RECEIVER, kIsFocused, 0)
+          .IsUserVisible());
+  EXPECT_FALSE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::HOME, kIsFocused, 0)
+          .IsUserVisible());
+  EXPECT_FALSE(ArcProcess(0, 0, "process", mojom::ProcessState::LAST_ACTIVITY,
+                          kIsFocused, 0)
+                   .IsUserVisible());
+  EXPECT_FALSE(ArcProcess(0, 0, "process", mojom::ProcessState::CACHED_ACTIVITY,
+                          kIsFocused, 0)
+                   .IsUserVisible());
+  EXPECT_FALSE(ArcProcess(0, 0, "process",
+                          mojom::ProcessState::CACHED_ACTIVITY_CLIENT,
+                          kIsFocused, 0)
+                   .IsUserVisible());
+  EXPECT_FALSE(ArcProcess(0, 0, "process", mojom::ProcessState::CACHED_EMPTY,
+                          kIsFocused, 0)
+                   .IsUserVisible());
+
+  // Exceptions: the function always returns true ignoring ProcessState for our
+  // HOME process.
+  EXPECT_TRUE(ArcProcess(0, 0, "org.chromium.arc.home",
+                         mojom::ProcessState::TOP, kIsFocused, 0)
+                  .IsUserVisible());
+  EXPECT_TRUE(ArcProcess(0, 0, "org.chromium.arc.home",
+                         mojom::ProcessState::HOME, kIsFocused, 0)
+                  .IsUserVisible());
+}
+
+TEST(ArcProcess, TestIsKillableForKernel) {
+  constexpr bool kIsFocused = false;
+
+  // Only PERSISITENT* processes are protected from the kernel OOM killer.
+  EXPECT_FALSE(ArcProcess(0, 0, "process", mojom::ProcessState::PERSISTENT,
+                          kIsFocused, 0)
+                   .IsKillableForKernel());
+  EXPECT_FALSE(ArcProcess(0, 0, "process", mojom::ProcessState::PERSISTENT_UI,
+                          kIsFocused, 0)
+                   .IsKillableForKernel());
+
+  // Both TOP+focused and TOP apps are still kernel-killable.
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::TOP, true, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::TOP, false, 0)
+                  .IsKillableForKernel());
+
+  // Others are kernel-killable.
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::BOUND_FOREGROUND_SERVICE,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::FOREGROUND_SERVICE, kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::TOP_SLEEPING,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::IMPORTANT_FOREGROUND, kIsFocused,
+                         0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::IMPORTANT_BACKGROUND, kIsFocused,
+                         0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::BACKUP, kIsFocused, 0)
+          .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::HEAVY_WEIGHT,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::SERVICE, kIsFocused, 0)
+          .IsKillableForKernel());
+  EXPECT_TRUE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::RECEIVER, kIsFocused, 0)
+          .IsKillableForKernel());
+  EXPECT_TRUE(
+      ArcProcess(0, 0, "process", mojom::ProcessState::HOME, kIsFocused, 0)
+          .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::LAST_ACTIVITY,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::CACHED_ACTIVITY,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process",
+                         mojom::ProcessState::CACHED_ACTIVITY_CLIENT,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+  EXPECT_TRUE(ArcProcess(0, 0, "process", mojom::ProcessState::CACHED_EMPTY,
+                         kIsFocused, 0)
+                  .IsKillableForKernel());
+
+  // Exceptions: the function always returns false ignoring ProcessState for our
+  // HOME process.
+  EXPECT_FALSE(ArcProcess(0, 0, "org.chromium.arc.home",
+                          mojom::ProcessState::TOP, kIsFocused, 0)
+                   .IsKillableForKernel());
+  EXPECT_FALSE(ArcProcess(0, 0, "org.chromium.arc.home",
+                          mojom::ProcessState::HOME, kIsFocused, 0)
+                   .IsKillableForKernel());
+}
+
 }  // namespace
 
 }  // namespace arc