Adding overview / layer framework to Activities so that unloaded / sleeping activities can be shown…

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/athena_test_base.h"
@@ skipping 37 matching lines @@
   }
 
   // ActivityViewModel overrides:
   virtual void Init() OVERRIDE {}
   virtual SkColor GetRepresentativeColor() const OVERRIDE { return 0; }
   virtual base::string16 GetTitle() const OVERRIDE { return title_; }
   virtual gfx::ImageSkia GetIcon() const OVERRIDE { return gfx::ImageSkia(); }
   virtual bool UsesFrame() const OVERRIDE { return true; }
   virtual views::View* GetContentsView() OVERRIDE { return view_; }
   virtual views::Widget* CreateWidget() OVERRIDE { return NULL; }
-  virtual void CreateOverviewModeImage() OVERRIDE {}
-  virtual gfx::ImageSkia GetOverviewModeImage() OVERRIDE { return image_; }
+  virtual gfx::ImageSkia GetOverviewModeImage() OVERRIDE {
+    return gfx::ImageSkia();
+  }
   virtual void PrepareContentsForOverview() OVERRIDE {}
   virtual void ResetContentsView() OVERRIDE {}
 
  private:
   // The presentation values.
   const base::string16 title_;
   gfx::ImageSkia image_;
 
   // The associated view.
   views::View* view_;
@@ skipping 55 matching lines @@
 // 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);
 
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_unloadable1->GetCurrentState());
-  DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_unloadable2->GetCurrentState());
+  // 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(
       MemoryPressureObserver::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(
@@ skipping 20 matching lines @@
   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(
       MemoryPressureObserver::MEMORY_PRESSURE_CRITICAL);
   DCHECK_NE(Activity::ACTIVITY_UNLOADED, app_visible->GetCurrentState());
@@ skipping 69 matching lines @@
 
   // Going back to a relaxed memory pressure should reload the old activities.
   ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
       MemoryPressureObserver::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 demoted from visible to invisible,
+// does not get thrown out of memory in the same step.
+TEST_F(ResourceManagerTest, NoUnloadFromVisible) {
+  // 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 ivisible.
+  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
+      MemoryPressureObserver::MEMORY_PRESSURE_CRITICAL);
+  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
+  EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app2->GetCurrentState());
+
+  // Applying low resource pressure again will unload it.
+  ResourceManager::Get()->SetMemoryPressureAndStopMonitoring(
+      MemoryPressureObserver::MEMORY_PRESSURE_CRITICAL);
+  EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app1->GetCurrentState());
+  EXPECT_EQ(Activity::ACTIVITY_UNLOADED, app2->GetCurrentState());
+}
+
 }  // namespace test
 }  // namespace athena