Delete athena/

athena/resource_manager/resource_manager_unittest.cc

-/// Copyright 2014 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 "athena/activity/public/activity.h"
-#include "athena/activity/public/activity_manager.h"
-#include "athena/activity/public/activity_view_model.h"
-#include "athena/resource_manager/memory_pressure_notifier.h"
-#include "athena/resource_manager/public/resource_manager.h"
-#include "athena/test/base/athena_test_base.h"
-#include "athena/test/base/sample_activity.h"
-#include "athena/wm/public/window_manager.h"
-#include "base/strings/utf_string_conversions.h"
-#include "ui/gfx/image/image_skia.h"
-#include "ui/views/view.h"
-#include "ui/views/widget/widget.h"
-
-namespace athena {
-namespace test {
-
-namespace {
-
-// A dummy test app activity which works without content / ShellAppWindow.
-class TestActivity : public SampleActivity {
- public:
-  explicit TestActivity(const std::string& title)
-      : SampleActivity(0, 0, base::UTF8ToUTF16(title)),
-        media_state_(ACTIVITY_MEDIA_STATE_NONE),
-        is_visible_(false) {}
-  ~TestActivity() override {}
-
-  void set_media_state(ActivityMediaState media_state) {
-    media_state_ = media_state;
-  }
-  void set_visible(bool visible) { is_visible_ = visible; }
-
-  // Activity overrides:
-  virtual bool IsVisible() override { return is_visible_; }
-  virtual ActivityMediaState GetMediaState() override { return media_state_; }
-
- private:
-  // The current media state.
-  ActivityMediaState media_state_;
-
-  // Returns if it is visible or not.
-  bool is_visible_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestActivity);
-};
-
-}  // namespace
-
-// Our testing base.
-class ResourceManagerTest : public AthenaTestBase {
- public:
-  ResourceManagerTest() {}
-  ~ResourceManagerTest() override {}
-
-  virtual void SetUp() override {
-    AthenaTestBase::SetUp();
-    // Override the delay to be instantaneous.
-    ResourceManager::Get()->SetWaitTimeBetweenResourceManageCalls(0);
-  }
-  virtual void TearDown() override {
-    while (!activity_list_.empty())
-      DeleteActivity(activity_list_[0]);
-    AthenaTestBase::TearDown();
-  }
-
-  TestActivity* CreateActivity(const std::string& title) {
-    TestActivity* activity = new TestActivity(title);
-    ActivityManager::Get()->AddActivity(activity);
-    activity->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-    activity_list_.push_back(activity);
-    return activity;
-  }
-
-  void DeleteActivity(Activity* activity) {
-    Activity::Delete(activity);
-    RunAllPendingInMessageLoop();
-    std::vector<TestActivity*>::iterator it = std::find(activity_list_.begin(),
-                                                        activity_list_.end(),
-                                                        activity);
-    DCHECK(it != activity_list_.end());
-    activity_list_.erase(it);
-  }
-
- private:
-  std::vector<TestActivity*> activity_list_;
-
-  DISALLOW_COPY_AND_ASSIGN(ResourceManagerTest);
-};
-
-// Only creates and destroys it to see that the system gets properly shut down.
-TEST_F(ResourceManagerTest, SimpleTest) {
-}
-
-// Test that we release an activity when the memory pressure goes critical.
-TEST_F(ResourceManagerTest, OnCriticalWillUnloadOneActivity) {
-  // Create a few dummy activities in the reverse order as we need them.
-  TestActivity* app_unloadable2 = CreateActivity("unloadable2");
-  TestActivity* app_unloadable1 = CreateActivity("unloadable1");
-  TestActivity* app_visible = CreateActivity("visible");
-  app_visible->set_visible(true);
-  app_unloadable1->set_visible(false);
-  app_unloadable2->set_visible(false);
-
-  // Set the initial visibility states.
-  app_visible->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app_unloadable1->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-  app_unloadable2->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-
-  // Call the resource manager and say we are in a critical memory condition.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_unloadable1->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable2->GetCurrentState());
-
-  // Calling it a second time will release the second app.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable1->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable2->GetCurrentState());
-
-  // Calling it once more will change nothing.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable1->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable2->GetCurrentState());
-}
-
-// Test that media playing activities only get unloaded if there is no other
-// way.
-TEST_F(ResourceManagerTest, OnCriticalMediaHandling) {
-  // Create a few dummy activities in the reverse order as we need them.
-  TestActivity* app_media_locked2 = CreateActivity("medialocked2");
-  TestActivity* app_unloadable = CreateActivity("unloadable2");
-  TestActivity* app_media_locked1 = CreateActivity("medialocked1");
-  TestActivity* app_visible = CreateActivity("visible");
-  app_visible->set_visible(true);
-  app_unloadable->set_visible(false);
-  app_media_locked1->set_visible(false);
-  app_media_locked2->set_visible(false);
-
-  app_media_locked1->set_media_state(
-      Activity::ACTIVITY_MEDIA_STATE_AUDIO_PLAYING);
-  app_media_locked2->set_media_state(Activity::ACTIVITY_MEDIA_STATE_RECORDING);
-
-  // Set the initial visibility states.
-  app_visible->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app_media_locked1->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-  app_unloadable->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-  app_media_locked2->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_media_locked1->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_unloadable->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_media_locked2->GetCurrentState());
-
-  // Calling it with a critical situation first, it will release the non media
-  // locked app.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_media_locked1->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_media_locked2->GetCurrentState());
-
-  // Calling it the second time, the oldest media playing activity will get
-  // unloaded.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_media_locked1->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_media_locked2->GetCurrentState());
-
-  // Calling it the third time, the oldest media playing activity will get
-  // unloaded.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_media_locked1->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_unloadable->GetCurrentState());
-  DCHECK_EQ(Activity::ACTIVITY_UNLOADED, app_media_locked2->GetCurrentState());
-}
-
-// Test the visibility of items.
-TEST_F(ResourceManagerTest, VisibilityChanges) {
-  // Create a few dummy activities in the reverse order as we need them.
-  TestActivity* app4 = CreateActivity("app4");
-  TestActivity* app3 = CreateActivity("app3");
-  TestActivity* app2 = CreateActivity("app2");
-  TestActivity* app1 = CreateActivity("app1");
-  app1->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app2->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app3->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app4->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-
-  // Applying low resource pressure should keep everything as is.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_LOW);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app3->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app4->GetCurrentState());
-
-  // Applying moderate resource pressure we should see 3 visible activities.
-  // This is testing an internal algorithm constant, but for the time being
-  // this should suffice.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_MODERATE);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app3->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app4->GetCurrentState());
-
-  // Applying higher pressure should get rid of everything unneeded.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app3->GetCurrentState());
-  // Note: This might very well be unloaded with this memory pressure.
-  EXPECT_NE(Activity::ACTIVITY_VISIBLE, app4->GetCurrentState());
-
-  // Once the split view mode gets turned on, more windows should become
-  // visible.
-  WindowManager::Get()->ToggleSplitViewForTest();
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app2->GetCurrentState());
-  EXPECT_NE(Activity::ACTIVITY_VISIBLE, app3->GetCurrentState());
-  EXPECT_NE(Activity::ACTIVITY_VISIBLE, app4->GetCurrentState());
-
-  // Going back to a relaxed memory pressure should reload the old activities.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_LOW);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app3->GetCurrentState());
-  EXPECT_NE(Activity::ACTIVITY_INVISIBLE, app4->GetCurrentState());
-}
-
-// Make sure that an activity which got just reduced from visible to invisible,
-// does not get thrown out of memory in the same step.
-TEST_F(ResourceManagerTest, NoUnloadFromVisible) {
-  // The timeout override in milliseconds.
-  const int kTimeoutOverrideInMs = 20;
-  // Tell the resource manager to wait for 20ms between calls.
-  ResourceManager::Get()->SetWaitTimeBetweenResourceManageCalls(
-      kTimeoutOverrideInMs);
-
-  // Create a few dummy activities in the reverse order as we need them.
-  TestActivity* app2 = CreateActivity("app2");
-  TestActivity* app1 = CreateActivity("app1");
-  app1->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app2->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-
-  // Applying low resource pressure should turn one item invisible.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-
-  // Trying to apply the memory pressure again does not do anything.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-
-  // Waiting and applying the pressure again should unload it.
-  usleep(kTimeoutOverrideInMs * 1000);
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_UNLOADED, app2->GetCurrentState());
-}
-
-// Make sure that ActivityVisibility changes will be updated instantaneously
-// when the ResourceManager is called for operation.
-TEST_F(ResourceManagerTest, VisibilityChangeIsInstantaneous) {
-  // Create a few dummy activities in the reverse order as we need them.
-  TestActivity* app3 = CreateActivity("app3");
-  TestActivity* app2 = CreateActivity("app2");
-  TestActivity* app1 = CreateActivity("app1");
-  app1->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app2->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app3->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-
-  // Tell the resource manager to wait for a long time between calls.
-  ResourceManager::Get()->SetWaitTimeBetweenResourceManageCalls(1000);
-
-  // Applying higher pressure should get rid of everything unneeded.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app3->GetCurrentState());
-
-  // Setting now one window visible again and call a second time should
-  // immediately change the state again.
-  app2->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app3->GetCurrentState());
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app3->GetCurrentState());
-}
-
-// Make sure that a timeout has to be reached before another resource managing
-// operations can be performed.
-TEST_F(ResourceManagerTest, ResourceChangeDelayed) {
-  // Create a few dummy activities in the reverse order as we need them.
-  TestActivity* app4 = CreateActivity("app4");
-  TestActivity* app3 = CreateActivity("app3");
-  TestActivity* app2 = CreateActivity("app2");
-  TestActivity* app1 = CreateActivity("app1");
-  app1->SetCurrentState(Activity::ACTIVITY_VISIBLE);
-  app2->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-  app3->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-  app4->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
-
-  // The timeout override in milliseconds.
-  const int kTimeoutOverrideInMs = 20;
-  // Tell the resource manager to wait for 20ms between calls.
-  ResourceManager::Get()->SetWaitTimeBetweenResourceManageCalls(
-      kTimeoutOverrideInMs);
-  // Applying higher pressure should get unload the oldest activity.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app3->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_UNLOADED, app4->GetCurrentState());
-  // Trying to apply the resource pressure again within the timeout time should
-  // not trigger any operation.
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app3->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_UNLOADED, app4->GetCurrentState());
-
-  // Passing the timeout however should allow for another call.
-  usleep(kTimeoutOverrideInMs * 1000);
-  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
-      ResourceManager::MEMORY_PRESSURE_CRITICAL);
-  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_UNLOADED, app3->GetCurrentState());
-  EXPECT_EQ(Activity::ACTIVITY_UNLOADED, app4->GetCurrentState());
-}
-
-}  // namespace test
-}  // namespace athena