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

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"
@@ skipping 35 matching lines @@
   AppActivityRegistry* app_activity_registry() {
     return app_activity_registry_;
   }
 
   // Activity:
   virtual ActivityViewModel* GetActivityViewModel() OVERRIDE {
     return this;
   }
   virtual void SetCurrentState(Activity::ActivityState state) OVERRIDE {
     current_state_ = state;
+    if (state == ACTIVITY_UNLOADED)
+      app_activity_registry_->Unload();
   }
   virtual ActivityState GetCurrentState() OVERRIDE {
     return current_state_;
   }
   virtual bool IsVisible() OVERRIDE {
     return true;
   }
   virtual ActivityMediaState GetMediaState() OVERRIDE {
     return Activity::ACTIVITY_MEDIA_STATE_NONE;
   }
   virtual aura::Window* GetWindow() OVERRIDE {
     return view_->GetWidget()->GetNativeWindow();
   }
 
   // AppActivity:
   virtual views::WebView* GetWebView() OVERRIDE { return NULL; }
 
   // ActivityViewModel:
   virtual void Init() OVERRIDE {}
   virtual SkColor GetRepresentativeColor() const OVERRIDE { return 0; }
   virtual base::string16 GetTitle() const OVERRIDE { return title_; }
   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 gfx::ImageSkia();
+  }
 
  private:
   // If known the registry which holds all activities for the associated app.
   AppActivityRegistry* app_activity_registry_;
 
   // The title of the activity.
   base::string16 title_;
 
   // Our view.
   views::View* view_;
@@ skipping 180 matching lines @@
   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();
+  RunAllPendingInMessageLoop();
   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();
+  RunAllPendingInMessageLoop();
   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();
   ASSERT_TRUE(activity_proxy);
@@ skipping 20 matching lines @@
   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();
+  RunAllPendingInMessageLoop();
   EXPECT_EQ(0, app_activity_registry->NumberOfActivities());
   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());
 
   DeleteActivity(activity_proxy);
@@ skipping 16 matching lines @@
       app_activity1->app_activity_registry();
   EXPECT_EQ(app_activity_registry, app_activity2->app_activity_registry());
   EXPECT_EQ(app_activity_registry, app_activity3->app_activity_registry());
   EXPECT_EQ(3, app_activity_registry->NumberOfActivities());
   EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app_activity1->GetCurrentState());
   EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app_activity2->GetCurrentState());
   EXPECT_EQ(Activity::ACTIVITY_VISIBLE, app_activity3->GetCurrentState());
 
   // After setting all activities to UNLOADED the application should unload.
   app_activity1->SetCurrentState(Activity::ACTIVITY_UNLOADED);
-  app_activity1->app_activity_registry()->Unload();
+  RunAllPendingInMessageLoop();
   EXPECT_EQ(0, test_extensions_delegate()->unload_called());
   app_activity2->SetCurrentState(Activity::ACTIVITY_UNLOADED);
-  app_activity2->app_activity_registry()->Unload();
+  RunAllPendingInMessageLoop();
   EXPECT_EQ(0, test_extensions_delegate()->unload_called());
   app_activity3->SetCurrentState(Activity::ACTIVITY_UNLOADED);
-  app_activity3->app_activity_registry()->Unload();
+  RunAllPendingInMessageLoop();
   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();
   ASSERT_TRUE(activity_proxy);
   EXPECT_NE(app_activity1, activity_proxy);
@@ skipping 17 matching lines @@
   // 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();
+  RunAllPendingInMessageLoop();
   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();
   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 still there..
   EXPECT_EQ(1, AppRegistry::Get()->NumberOfApplications());
   EXPECT_TRUE(app_activity_registry->unloaded_activity_proxy());
   Activity::Delete(app_activity_registry->unloaded_activity_proxy());
   EXPECT_EQ(0, AppRegistry::Get()->NumberOfApplications());
 }
 
 }  // namespace test
 }  // namespace athena