Ensure that an activity is activated when overview mode is exited

athena/wm/window_overview_mode.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/wm/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 75 matching lines @@
                         SplitViewController* split_view_controller) {
   window->ClearProperty(kWindowOverviewState);
 
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
 
   settings.AddObserver(new ui::ClosureAnimationObserver(
       base::Bind(&HideWindowIfNotVisible, window, split_view_controller)));
-
   window->SetTransform(gfx::Transform());
 
   // Reset the window opacity in case the user is dragging a window.
   window->layer()->SetOpacity(1.0f);
 
   wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
 }
 
 gfx::RectF GetTransformedBounds(aura::Window* window) {
   gfx::Transform transform;
@@ skipping 457 matching lines @@
     dragged_window_->layer()->SetOpacity(1.f);
     dragged_window_ = NULL;
   }
 
   void EndDragWindow(const ui::GestureEvent& gesture) {
     CHECK(dragged_window_);
     CHECK(overview_toolbar_);
     OverviewToolbar::ActionType action = overview_toolbar_->current_action();
     overview_toolbar_.reset();
     if (action == OverviewToolbar::ACTION_TYPE_SPLIT) {
-      delegate_->OnSplitViewMode(NULL, dragged_window_);
+      delegate_->OnSelectSplitViewWindow(NULL,
+                                         dragged_window_,
+                                         dragged_window_);
       return;
     }
 
     // If the window is dropped on one of the left/right windows in split-mode,
     // then switch that window.
     aura::Window* split_drop = GetSplitWindowDropTarget(gesture);
     if (split_drop) {
       aura::Window* left = split_view_controller_->left_window();
       aura::Window* right = split_view_controller_->right_window();
       if (left == split_drop)
         left = dragged_window_;
       else
         right = dragged_window_;
-      delegate_->OnSplitViewMode(left, right);
+      delegate_->OnSelectSplitViewWindow(left, right, dragged_window_);
       return;
     }
 
     if (ShouldCloseDragWindow(gesture))
       CloseDragWindow(gesture);
     else
       RestoreDragWindow();
   }
 
   void SelectWindow(aura::Window* window) {
     if (!split_view_controller_->IsSplitViewModeActive()) {
       delegate_->OnSelectWindow(window);
     } else {
       // If the selected window is one of the left/right windows, then keep the
       // current state.
       if (window == split_view_controller_->left_window() ||
           window == split_view_controller_->right_window()) {
-        delegate_->OnSplitViewMode(split_view_controller_->left_window(),
-                                   split_view_controller_->right_window());
+        delegate_->OnSelectSplitViewWindow(
+            split_view_controller_->left_window(),
+            split_view_controller_->right_window(),
+            window);
       } else {
         delegate_->OnSelectWindow(window);
       }
     }
   }
 
+  // WindowOverviewMode:
+  virtual void SelectDefaultWindow() OVERRIDE {
+    aura::Window::Windows windows = window_list_provider_->GetWindowList();
+    if (windows.empty())
+      return;
+
+    // TODO(pkotwicz): Do not select a window which is about to be deleted.
+    SelectWindow(windows.back());
+  }
+
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
     if (mouse->type() == ui::ET_MOUSE_PRESSED) {
       aura::Window* select = SelectWindowAt(mouse);
       if (select) {
         mouse->SetHandled();
         SelectWindow(select);
       }
     } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
       DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
@@ skipping 110 matching lines @@
     aura::Window* container,
     const WindowListProvider* window_list_provider,
     SplitViewController* split_view_controller,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider,
                                  split_view_controller, delegate));
 }
 
 }  // namespace athena