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.
+    // TODO(skuhne): After the decision is made how we want to handle visibility
+    // transitions (issue 421680) this code might change.
+    // If the proxy was the active window, its deletion will cause a window
+    // 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());
+    } 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/09 04:53:33]

Can you move Activity::Delegate(app_proxy) before moving window so that both
path does delete -> restacking

[Mr4D (OOO till 08-26), 2014/10/09 14:46:44]

That is what I tried to tell you yesterday - no this order is crucial. By
deleting the activity, in one case the focused window will get deleted causing
the next foucussable window to bubble to the front (since this window is yet
hidden and therefore not activatable). So the move has to be done *after* the
reorder.
In the other case however you have to first reorganize the window relative to
the proxy and then delete it - otherwise the proxy is gone and you cannot move
the window into its position. Note also that in that case the activation is not
on the proxy - which is this difference about.

[oshima, 2014/10/09 16:06:43]

I see, in that case, can you update the comment why it's doing this way
rather than what it is doing?

[Mr4D (OOO till 08-26), 2014/10/09 17:28:03]

Done.

+    }
+    // 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