Index: athena/resource_manager/resource_manager_unittest.cc |
diff --git a/athena/resource_manager/resource_manager_unittest.cc b/athena/resource_manager/resource_manager_unittest.cc |
deleted file mode 100644 |
index bbb7595cbe08b4f0c104654fde892e6a9cf54ef7..0000000000000000000000000000000000000000 |
--- a/athena/resource_manager/resource_manager_unittest.cc |
+++ /dev/null |
@@ -1,362 +0,0 @@ |
-/// 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 |