Adding application lifetime tests to athena, allowing to override focus request for applciations

athena/content/app_activity_browsertest.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/resource_manager/public/resource_manager.h"
+#include "athena/test/base/activity_lifetime_tracker.h"
 #include "athena/test/chrome/athena_app_browsertest.h"
+#include "athena/test/chrome/test_util.h"
+#include "athena/wm/public/window_list_provider.h"
+#include "athena/wm/public/window_manager.h"
+#include "base/strings/utf_string_conversions.h"
+#include "ui/aura/client/focus_client.h"
+#include "ui/wm/core/window_util.h"
 
 namespace athena {
 
-typedef AthenaAppBrowserTest AppActivityBrowserTest;
+namespace {
+// The test URL to navigate to.
+const char kTestUrl[] = "chrome:about";
+}
+
+class AppActivityBrowserTest : public AthenaAppBrowserTest {
+ public:
+  AppActivityBrowserTest() {}
+  virtual ~AppActivityBrowserTest() {}
+
+  // AthenaAppBrowserTest:
+  virtual void SetUpOnMainThread() override {
+    tracker_.reset(new ActivityLifetimeTracker);
+    AthenaAppBrowserTest::SetUpOnMainThread();
+  }
+
+  virtual void TearDownOnMainThread() override {
+    tracker_.reset();
+    AthenaAppBrowserTest::TearDownOnMainThread();
+  }
+
+ protected:
+  // A |proxy_activity| got deleted and this function waits, using the |tracker|
+  // until the application got restarted returning the new application activity.
+  Activity* WaitForProxyDestruction(Activity* proxy_activity) {
+    ActivityLifetimeTracker tracker;
+    void* deleted_activity = NULL;
+    Activity* app_activity = NULL;
+    while (!app_activity && !deleted_activity) {
+      deleted_activity = tracker_->GetDeletedActivityAndReset();
+      app_activity = tracker_->GetNewActivityAndReset();
+      test_util::WaitUntilIdle();
+      usleep(5000);
+    }
+    EXPECT_EQ(deleted_activity, proxy_activity);
+    EXPECT_TRUE(app_activity);
+    return app_activity;
+  }
+
+  // Returns true when the window of the |activity| has the focus.
+  bool IsActivityActive(Activity* activity) {
+    return wm::IsActiveWindow(activity->GetWindow());
+  }
+
+  // Create a setup where the frontmost window is a web activity and then
+  // an unloaded app activity (proxy). Note that the resource manager will be
+  // set to CRITICAL to force the application to unload.
+  void SetUpWebAndProxyActivity(Activity** web_activity,
+                                Activity** proxy_activity) {
+    // Create an application activity.
+    Activity* app_activity = CreateTestAppActivity(GetTestAppID());
+    ASSERT_TRUE(app_activity);
+    EXPECT_EQ(app_activity, tracker_->GetNewActivityAndReset());
+    EXPECT_EQ(NULL, tracker_->GetDeletedActivityAndReset());
+
+    // Then a web activity (which will then be in front of the app).
+    *web_activity = test_util::CreateTestWebActivity(
+        test_util::GetBrowserContext(),
+        base::UTF8ToUTF16("App1"),
+        GURL(kTestUrl));
+    ASSERT_TRUE(*web_activity);
+    EXPECT_EQ(*web_activity, tracker_->GetNewActivityAndReset());
+    EXPECT_EQ(NULL, tracker_->GetDeletedActivityAndReset());
+
+    const aura::Window::Windows& windows =
+        WindowManager::Get()->GetWindowListProvider()->GetWindowList();
+
+    // The order of windows should now be: Web activity, app activity.
+    EXPECT_EQ(app_activity->GetWindow(), windows[0]);
+    EXPECT_EQ((*web_activity)->GetWindow(), windows[1]);
+
+    // We let the ResourceManager unload now the app. To accomplish this, we
+    // first set the app to INIVSIBLE and then let the ResourceManager unload it
+    // by turning on the critical memory pressure.
+    app_activity->SetCurrentState(Activity::ACTIVITY_INVISIBLE);
+    EXPECT_EQ(Activity::ACTIVITY_INVISIBLE, app_activity->GetCurrentState());
+    test_util::SendTestMemoryPressureEvent(
+        ResourceManager::MEMORY_PRESSURE_CRITICAL);
+    test_util::WaitUntilIdle();
+
+    *proxy_activity = tracker_->GetNewActivityAndReset();
+    ASSERT_TRUE(*proxy_activity);
+    EXPECT_NE(app_activity, *proxy_activity);
+    EXPECT_EQ(app_activity, tracker_->GetDeletedActivityAndReset());
+
+    // Check that the order of windows is correct (the proxy is at the second
+    // location).
+    EXPECT_EQ((*proxy_activity)->GetWindow(), windows[0]);
+    EXPECT_EQ((*web_activity)->GetWindow(), windows[1]);
+  }
+
+ private:
+  // The activity tracker which is used for asynchronous operations.
+  scoped_ptr<ActivityLifetimeTracker> tracker_;
+  DISALLOW_COPY_AND_ASSIGN(AppActivityBrowserTest);
+};
 
 // Tests that an application can be loaded.
 IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, StartApplication) {
   // There should be an application we can start.
   ASSERT_TRUE(!GetTestAppID().empty());
 
   // We should be able to start the application.
   ASSERT_TRUE(CreateTestAppActivity(GetTestAppID()));
 }
 
+// Test that creating an application (without a particular activity order
+// location) should activate it initially.
+IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, CreatedAppGetsFocus) {
+  Activity* web_activity =
+      test_util::CreateTestWebActivity(test_util::GetBrowserContext(),
+                                       base::UTF8ToUTF16("App1"),
+                                       GURL(kTestUrl));
+  EXPECT_TRUE(IsActivityActive(web_activity));
+
+  Activity* app_activity = CreateTestAppActivity(GetTestAppID());
+  EXPECT_TRUE(IsActivityActive(app_activity));
+}
+
+// Test that setting an application state to UNLOADED a proxy gets created and
+// upon changing it to invisible it gets reloaded it its current list location.
+IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, UnloadReloadApplicationInPlace) {
+  // Set up the experiment.
+  Activity* proxy_activity = NULL;
+  Activity* web_activity = NULL;
+  SetUpWebAndProxyActivity(&web_activity, &proxy_activity);
+  // By returning to a low memory pressure the application should start again.
+  test_util::SendTestMemoryPressureEvent(ResourceManager::MEMORY_PRESSURE_LOW);
+  Activity* app_activity = WaitForProxyDestruction(proxy_activity);
+  proxy_activity = NULL;  // The proxy is gone now.
+
+  // After this, the application should remain at its current location in the
+  // stack and the current window should stay active.
+  const aura::Window::Windows& windows =
+      WindowManager::Get()->GetWindowListProvider()->GetWindowList();
+  EXPECT_EQ(app_activity->GetWindow(), windows[0]);
+  EXPECT_EQ(web_activity->GetWindow(), windows[1]);
+  EXPECT_TRUE(IsActivityActive(web_activity));
+}
+
+// Check that activating an unloaded application will bring it properly to the
+// front of the stack (and activate it).
+IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, ReloadActivatedApplication) {
+  // Set up the experiment.
+  Activity* proxy_activity = NULL;
+  Activity* web_activity = NULL;
+  SetUpWebAndProxyActivity(&web_activity, &proxy_activity);
+
+  // Activating the proxy should push back the web app, lauch the application,
+  // kill the proxy and turn it active.
+  proxy_activity->GetWindow()->Show();
+  wm::ActivateWindow(proxy_activity->GetWindow());
+  const aura::Window::Windows& windows =
+      WindowManager::Get()->GetWindowListProvider()->GetWindowList();
+  EXPECT_EQ(web_activity->GetWindow(), windows[0]);
+
+  Activity* app_activity = WaitForProxyDestruction(proxy_activity);
+  proxy_activity = NULL;  // The proxy is gone now.
+
+  // After this, the application should remain at its current location in the
+  // stack and the activation focus should remain on the current window as well.
+  EXPECT_EQ(app_activity->GetWindow(), windows[1]);
+  EXPECT_TRUE(IsActivityActive(app_activity));
+  EXPECT_EQ(web_activity->GetWindow(), windows[0]);
+}
+
+// Check that moving a proxy window to the front will properly restart the app
+// and activate it.
+IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, ReloadMovedApplication) {
+  // Set up the experiment.
+  Activity* proxy_activity = NULL;
+  Activity* web_activity = NULL;
+  SetUpWebAndProxyActivity(&web_activity, &proxy_activity);
+  // Moving the window to the front will restart the app.
+  WindowManager::Get()->GetWindowListProvider()->StackWindowFrontOf(
+      proxy_activity->GetWindow(),
+      web_activity->GetWindow());
+  const aura::Window::Windows& windows =
+      WindowManager::Get()->GetWindowListProvider()->GetWindowList();
+  EXPECT_EQ(web_activity->GetWindow(), windows[0]);
+
+  Activity* app_activity = WaitForProxyDestruction(proxy_activity);
+  proxy_activity = NULL;  // The proxy is gone now.
+
+  // After this, the application should remain at its current location in the
+  // stack and the activation focus should remain on the current window as well.
+  EXPECT_EQ(app_activity->GetWindow(), windows[1]);
+  EXPECT_TRUE(IsActivityActive(app_activity));
+  EXPECT_EQ(web_activity->GetWindow(), windows[0]);
+}
+
 }  // namespace athena