ESC accelerator and consistent overview mode for Athena homecard

athena/wm/window_manager_impl.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_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
@@ skipping 175 matching lines @@
     // Relayout so that windows are maximzied.
     container_->layout_manager()->OnWindowResized();
   } else if (split_view_controller_->CanActivateSplitViewMode()) {
     FOR_EACH_OBSERVER(WindowManagerObserver,
                       observers_,
                       OnSplitViewModeEnter());
     split_view_controller_->ActivateSplitMode(NULL, NULL, NULL);
   }
 }
 
-void WindowManagerImpl::ToggleOverview() {
-  if (IsOverviewModeActive()) {
-    SetInOverview(false);
+// Wraps SetInOverview(), and also activates old active window upon deactivation
+void WindowManagerImpl::ActivateOverview(bool activate) {
+  if (IsOverviewModeActive() == activate)
+    return;
 
+  SetInOverview(activate);
+  if (!activate) {
     // Activate the window which was active prior to entering overview.
     const aura::Window::Windows windows =
         window_list_provider_->GetWindowList();
     if (!windows.empty()) {
       aura::Window* window = windows.back();
       // Show the window in case the exit overview animation has finished and
       // |window| was hidden.
       window->Show();
 
       wm::ActivateWindow(window);
     }
-  } else {
-    SetInOverview(true);
   }
 }
 
 bool WindowManagerImpl::IsOverviewModeActive() {
   return overview_;
 }
 
 void WindowManagerImpl::SetInOverview(bool active) {

[pkotwicz, 2014/10/07 01:30:26]

+oshima for his opinion. I remember that the architecture of this was
controversial

How about splitting WindowManagerImpl::SetInOverview() into
WindowManagerImpl::EnterOverview() and
WindowManagerImpl::ExitOverview(aura::Window* to_activate)

WindowManagerImpl::ExitOverview() would have special behavior when NULL is
passed in.

Please wait for Oshima's opinion before proceeding

[oshima, 2014/10/08 00:45:45]

Yes, that'd be better, although this CL is unrelated to that change. If you can
work on it in separate CL, that'd be great.

[Greg Levin, 2014/10/08 18:21:13]

Acknowledged.

[Greg Levin, 2014/10/08 18:21:13]

As per Oshima's suggestion, I'll do this refactor in a subsequent CL

[pkotwicz, 2014/10/08 19:45:25]

I would recommend either:
a) Splitting WindowManagerImpl::SetInOverview() into two functions as a CL prior
to this one. This would avoid you having to change most of the files that you
changed in this CL in the subsequent CL as well
b) Not changing the athena::WindowManager API in this CL (and doing so in the
subsequent CL)

   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
+  const AcceleratorData esc_accelerator_data = {TRIGGER_ON_PRESS,
+                                                ui::VKEY_ESCAPE,
+                                                ui::EF_NONE,
+                                                CMD_EXIT_OVERVIEW,
+                                                AF_NONE};
+
   bezel_controller_->set_left_right_delegate(
       active ? NULL : split_view_controller_.get());
   if (active) {
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
 
     // Note: The window_list_provider_ resembles the exact window list of the
     // container, so no re-stacking is required before showing the OverviewMode.
     overview_ = WindowOverviewMode::Create(
         container_.get(), window_list_provider_.get(),
         split_view_controller_.get(), this);
+    AcceleratorManager::Get()->RegisterAccelerator(esc_accelerator_data, this);
   } else {
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
+    AcceleratorManager::Get()->UnregisterAccelerator(esc_accelerator_data,
+                                                     this);
   }
 }
 
 void WindowManagerImpl::InstallAccelerators() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, CMD_TOGGLE_OVERVIEW,
        AF_NONE},
       {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_CONTROL_DOWN,
        CMD_TOGGLE_SPLIT_VIEW, AF_NONE},
   };
@@ skipping 67 matching lines @@
     container_.reset();
 }
 
 bool WindowManagerImpl::IsCommandEnabled(int command_id) const {
   return true;
 }
 
 bool WindowManagerImpl::OnAcceleratorFired(int command_id,
                                            const ui::Accelerator& accelerator) {
   switch (command_id) {
+    case CMD_EXIT_OVERVIEW:
+      ActivateOverview(false);
+      break;
     case CMD_TOGGLE_OVERVIEW:
-      ToggleOverview();
+      ActivateOverview(!IsOverviewModeActive());
       break;
     case CMD_TOGGLE_SPLIT_VIEW:
       ToggleSplitView();
       break;
   }
   return true;
 }
 
 aura::Window* WindowManagerImpl::GetWindowBehind(aura::Window* window) {
   const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
@@ skipping 88 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena