Decoupling visibility states from webcontent, adding visibility management in ResourceManager

athena/content/app_activity_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_factory.h"
 #include "athena/activity/public/activity_manager.h"
 #include "athena/content/app_activity.h"
 #include "athena/content/app_activity_registry.h"
 #include "athena/content/public/app_registry.h"
 #include "athena/extensions/public/extensions_delegate.h"
+#include "athena/resource_manager/public/resource_manager.h"
 #include "athena/test/athena_test_base.h"
 #include "extensions/common/extension_set.h"
 #include "ui/aura/window.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace content {
 class BrowserContext;
 }
 
@@ skipping 127 matching lines @@
   }
 
   // A function to create an Activity.
   TestAppActivity* CreateAppActivity(const std::string& app_id) {
     TestAppActivity* activity = new TestAppActivity(app_id);
     ActivityManager::Get()->AddActivity(activity);
     return activity;
   }
 
   void CloseActivity(Activity* activity) {
-    delete activity;
+    Activity::CloseActivity(activity);
     RunAllPendingInMessageLoop();
   }
 
   // Get the position of the activity in the navigation history.
   int GetActivityPosition(Activity* activity) {
     aura::Window* window = activity->GetActivityViewModel()->GetContentsView()
                                ->GetWidget()->GetNativeWindow();
     aura::Window::Windows windows = activity->GetWindow()->parent()->children();
     for (size_t i = 0; i < windows.size(); i++) {
       if (windows[i] == window)
         return i;
     }
     return -1;
   }
 
+  // To avoid interference of the ResourceManager in these AppActivity
+  // framework tests, we disable the ResourceManager for some tests.
+  // Every use/interference of this function gets explained.
+  void DisableResourceManager() {
+    ResourceManager::Get()->Pause(true);
+  }
+
  protected:
   TestExtensionsDelegate* test_extensions_delegate() {
     return test_extensions_delegate_;
   }
 
  private:
   TestExtensionsDelegate* test_extensions_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AppActivityTest);
 };
@@ skipping 61 matching lines @@
     EXPECT_EQ(1, app_activity1->app_activity_registry()->NumberOfActivities());
     CloseActivity(app_activity1);
   }
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
   EXPECT_EQ(0, test_extensions_delegate()->unload_called());
   EXPECT_EQ(0, test_extensions_delegate()->restart_called());
 }
 
 // Test unload and the creation of the proxy, then "closing the activity".
 TEST_F(AppActivityTest, TestUnloadFollowedByClose) {
+  // We do not want the ResourceManager to interfere with this test. In this
+  // case it would (dependent on its current internal implementation)
+  // automatically re-load the unloaded activity if it is in an "active"
+  // position.
+  DisableResourceManager();
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
 
   TestAppActivity* app_activity = CreateAppActivity(kDummyApp1);
   EXPECT_EQ(1, AppRegistry::Get()->NumberOfApplications());
   AppActivityRegistry* app_activity_registry =
       app_activity->app_activity_registry();
   EXPECT_EQ(1, app_activity_registry->NumberOfActivities());
   EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app_activity->GetCurrentState());
 
   // Calling Unload now should not do anything since at least one activity in
   // the registry is still visible.
   app_activity_registry->Unload();
   EXPECT_EQ(0, test_extensions_delegate()->unload_called());
 
   // After setting our activity to unloaded however the application should get
   // unloaded as requested.
   app_activity->SetCurrentState(Activity::ACTIVITY_UNLOADED);
   app_activity_registry->Unload();
   EXPECT_EQ(1, test_extensions_delegate()->unload_called());
 
   // Check that our created application is gone, and instead a proxy got
   // created.
   ASSERT_EQ(1, AppRegistry::Get()->NumberOfApplications());
   ASSERT_EQ(app_activity_registry,
             AppRegistry::Get()->GetAppActivityRegistry(kDummyApp1, NULL));
   EXPECT_EQ(0, app_activity_registry->NumberOfActivities());
-  Activity* activity_proxy =
-      app_activity_registry->unloaded_activity_proxy_for_test();
+  Activity* activity_proxy = app_activity_registry->unloaded_activity_proxy();
   ASSERT_TRUE(activity_proxy);
   EXPECT_NE(app_activity, activity_proxy);
   EXPECT_EQ(Activity::ACTIVITY_UNLOADED, activity_proxy->GetCurrentState());
+  EXPECT_EQ(0, test_extensions_delegate()->restart_called());
 
   // Close the proxy object and make sure that nothing bad happens.
   CloseActivity(activity_proxy);
 
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
   EXPECT_EQ(1, test_extensions_delegate()->unload_called());
   EXPECT_EQ(0, test_extensions_delegate()->restart_called());
 }
 
 // Test that when unloading an app while multiple apps / activities are present,
 // the proxy gets created in the correct location.
 TEST_F(AppActivityTest, TestUnloadProxyLocation) {
   // Set up some activities for some applications.
   TestAppActivity* app_activity1a = CreateAppActivity(kDummyApp1);
   TestAppActivity* app_activity2a = CreateAppActivity(kDummyApp2);
   TestAppActivity* app_activity2b = CreateAppActivity(kDummyApp2);
   TestAppActivity* app_activity1b = CreateAppActivity(kDummyApp1);
   EXPECT_EQ(3, GetActivityPosition(app_activity1b));
   EXPECT_EQ(2, GetActivityPosition(app_activity2b));
   EXPECT_EQ(1, GetActivityPosition(app_activity2a));
   EXPECT_EQ(0, GetActivityPosition(app_activity1a));
 
   // Unload an app and make sure that the proxy is in the newest activity slot.
   AppActivityRegistry* app_activity_registry =
       app_activity2a->app_activity_registry();
   app_activity2a->SetCurrentState(Activity::ACTIVITY_UNLOADED);
   app_activity2b->SetCurrentState(Activity::ACTIVITY_UNLOADED);
   app_activity2a->app_activity_registry()->Unload();
   EXPECT_EQ(0, app_activity_registry->NumberOfActivities());
-  Activity* activity_proxy =
-      app_activity_registry->unloaded_activity_proxy_for_test();
+  Activity* activity_proxy = app_activity_registry->unloaded_activity_proxy();
   RunAllPendingInMessageLoop();
 
   EXPECT_EQ(2, GetActivityPosition(app_activity1b));
   EXPECT_EQ(1, GetActivityPosition(activity_proxy));
   EXPECT_EQ(0, GetActivityPosition(app_activity1a));
+  EXPECT_EQ(0, test_extensions_delegate()->restart_called());
 
   CloseActivity(activity_proxy);
   CloseActivity(app_activity1b);
   CloseActivity(app_activity1a);
 }
 
 // Test that an unload with multiple activities of the same app will only unload
 // when all activities were marked for unloading.
 TEST_F(AppActivityTest, TestMultipleActivityUnloadLock) {
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
@@ skipping 22 matching lines @@
   EXPECT_EQ(0, test_extensions_delegate()->unload_called());
   app_activity3->SetCurrentState(Activity::ACTIVITY_UNLOADED);
   app_activity3->app_activity_registry()->Unload();
   EXPECT_EQ(1, test_extensions_delegate()->unload_called());
 
   // Now there should only be the proxy activity left.
   ASSERT_EQ(1, AppRegistry::Get()->NumberOfApplications());
   ASSERT_EQ(app_activity_registry,
             AppRegistry::Get()->GetAppActivityRegistry(kDummyApp1, NULL));
   EXPECT_EQ(0, app_activity_registry->NumberOfActivities());
-  Activity* activity_proxy =
-      app_activity_registry->unloaded_activity_proxy_for_test();
+  Activity* activity_proxy = app_activity_registry->unloaded_activity_proxy();
   ASSERT_TRUE(activity_proxy);
   EXPECT_NE(app_activity1, activity_proxy);
   EXPECT_NE(app_activity2, activity_proxy);
   EXPECT_NE(app_activity3, activity_proxy);
   EXPECT_EQ(Activity::ACTIVITY_UNLOADED, activity_proxy->GetCurrentState());
 
   // Close the proxy object and make sure that nothing bad happens.
   CloseActivity(activity_proxy);
 
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
   EXPECT_EQ(1, test_extensions_delegate()->unload_called());
   EXPECT_EQ(0, test_extensions_delegate()->restart_called());
 }
 
 // Test that activating the proxy will reload the application.
 TEST_F(AppActivityTest, TestUnloadWithReload) {
+  // We do not want the ResourceManager to interfere with this test. In this
+  // case it would (dependent on its current internal implementation)
+  // automatically re-load the unloaded activity if it is in an "active"
+  // position.
+  DisableResourceManager();
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
 
   TestAppActivity* app_activity = CreateAppActivity(kDummyApp1);
   AppActivityRegistry* app_activity_registry =
       app_activity->app_activity_registry();
 
   // Unload the activity.
   app_activity->SetCurrentState(Activity::ACTIVITY_UNLOADED);
   app_activity_registry->Unload();
   EXPECT_EQ(1, test_extensions_delegate()->unload_called());
 
   // Try to activate the activity again. This will force the application to
   // reload.
-  Activity* activity_proxy =
-      app_activity_registry->unloaded_activity_proxy_for_test();
+  Activity* activity_proxy = app_activity_registry->unloaded_activity_proxy();
   activity_proxy->SetCurrentState(Activity::ACTIVITY_VISIBLE);
   EXPECT_EQ(1, test_extensions_delegate()->restart_called());
 
   // However - the restart in this test framework does not really restart and
-  // all objects should be gone now.
+  // all objects should be still there..
+  EXPECT_EQ(1, AppRegistry::Get()->NumberOfApplications());
+  EXPECT_TRUE(app_activity_registry->unloaded_activity_proxy());
+  Activity::CloseActivity(app_activity_registry->unloaded_activity_proxy());
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
 }
 
 }  // namespace test
 }  // namespace athena