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

athena/content/app_activity.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/content/app_activity.h"
 
 #include "athena/activity/public/activity_manager.h"
 #include "athena/content/app_activity_registry.h"
 #include "athena/content/content_proxy.h"
 #include "athena/content/media_utils.h"
 #include "athena/content/public/app_registry.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/aura/window.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/core/window_util.h"
 
 namespace athena {
 
 // TODO(mukai): specifies the same accelerators of WebActivity.
 AppActivity::AppActivity(const std::string& app_id,
                          views::WebView* web_view)
     : app_id_(app_id),
       web_view_(web_view),
       current_state_(ACTIVITY_UNLOADED),
       app_activity_registry_(NULL) {
@@ skipping 73 matching lines @@
 }
 
 void AppActivity::Init() {
   DCHECK(app_activity_registry_);
   Activity* app_proxy = app_activity_registry_->unloaded_activity_proxy();
   if (app_proxy) {
     // Note: At this time the |AppActivity| did not get registered to the
     // |ResourceManager| - so we can move it around if needed.
     WindowListProvider* window_list_provider =
         WindowManager::Get()->GetWindowListProvider();
-    window_list_provider->StackWindowFrontOf(app_proxy->GetWindow(),
-                                             GetWindow());
-    Activity::Delete(app_proxy);
-    // With the removal the object, the proxy should be deleted.
+
+    // If the proxy was the active window, its deletion will cause a window

[oshima, 2014/10/08 19:02:30]

Since the window may not be visible when created, we should do this when the
window becomes visible, shouldn't we?

[Mr4D (OOO till 08-26), 2014/10/08 23:48:16]

As stated in the next comment - the visibility will be resolved when the app
gets shown. All we do is to position it properly (no activation).

Beside that the app proxy should be deleted as early as possible because
otherwise the proxy activity has influence on the resource manager's decisions
and that should not be (unless we want to add there more logic to avoid this).

I added a comment to revisit this code after discussing how we want to address
temporarily invisibility of applications. (Same applies for the other comments
here)

[oshima, 2014/10/09 04:53:32]

Acknowledged.

+    // reordering since the next activatable window in line will move up to the
+    // front. Since the application window is still hidden at this time, it is
+    // not yet activatable and the window behind it will move to the front.
+    if (wm::IsActiveWindow(app_proxy->GetWindow())) {
+      // Delete the proxy window first and then move the new window to the top
+      // of the stack, replacing the proxy window.
+      Activity::Delete(app_proxy);
+      window_list_provider->StackWindowFrontOf(
+          GetWindow(),
+          window_list_provider->GetWindowList().back());

[oshima, 2014/10/08 19:02:30]

If the app_proxy's window was active, shouldn't we activate the new window?

[Mr4D (OOO till 08-26), 2014/10/08 23:48:16]

A hidden window cannot be activated. As you have pointed out, applications can
create their window hidden. The activation will either happen in
BaseWindow::Show() - or - it will remain hidden and the currently activated
window will remain activated (and visible since the window is hidden).

[oshima, 2014/10/09 04:53:32]

Acknowledged.

+    } else {
+      // The app window goes in front of the proxy window.
+      window_list_provider->StackWindowFrontOf(GetWindow(),
+                                               app_proxy->GetWindow());
+      Activity::Delete(app_proxy);

[oshima, 2014/10/08 19:02:30]

how about something like

bool was_active = wm::IsActiveWindow(app_proxy->GetWindow());
Activity::Delegate(app_proxy);
if (was_active)
   wm::ActivateWindow(GetWindow());
else
  StackWindowFrontOF....

[Mr4D (OOO till 08-26), 2014/10/08 23:48:16]

As stated above already - the window might neither be nor become visible - so
ActivateWindow might not work on it.

+    }
+    // The proxy should now be deleted.
     DCHECK(!app_activity_registry_->unloaded_activity_proxy());
   }
 }
 
 SkColor AppActivity::GetRepresentativeColor() const {
   // TODO(sad): Compute the color from the favicon.
   return SK_ColorGRAY;
 }
 
 base::string16 AppActivity::GetTitle() const {
   return web_view_->GetWebContents()->GetTitle();
 }
 
 gfx::ImageSkia AppActivity::GetIcon() const {
   return gfx::ImageSkia();
 }
 
 bool AppActivity::UsesFrame() const {
   return false;
 }
 
 views::Widget* AppActivity::CreateWidget() {
+  // Before we remove the proxy, we have to register the activity and
+  // initialize its to move it to the proper activity list location.
+  RegisterActivity();
+  Init();
   // Make sure the content gets properly shown.
   if (current_state_ == ACTIVITY_VISIBLE) {
     HideContentProxy();
   } else if (current_state_ == ACTIVITY_INVISIBLE) {
     ShowContentProxy();
   } else {
     // If not previously specified, we change the state now to invisible..
     SetCurrentState(ACTIVITY_INVISIBLE);
   }
-  RegisterActivity();
   return web_view_->GetWidget();
 }
 
 views::View* AppActivity::GetContentsView() {
   return web_view_;
 }
 
 gfx::ImageSkia AppActivity::GetOverviewModeImage() {
   if (content_proxy_.get())
     return content_proxy_->GetContentImage();
@@ skipping 56 matching lines @@
 void AppActivity::HideContentProxy() {
   content_proxy_.reset();
 }
 
 void AppActivity::ShowContentProxy() {
   if (!content_proxy_.get() && web_view_)
     content_proxy_.reset(new ContentProxy(web_view_));
 }
 
 }  // namespace athena