Add window cycle completion and cancellation accelerators in mus+ash.

ash/mus/accelerators/accelerator_controller_registrar.cc

 // Copyright 2016 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 "ash/mus/accelerators/accelerator_controller_registrar.h"
 
 #include <limits>
 
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/accelerators/accelerator_router.h"
+#include "ash/common/wm/window_cycle_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/window_manager.h"
 #include "ash/public/interfaces/event_properties.mojom.h"
 #include "ash/shell.h"
 #include "base/logging.h"
 #include "services/ui/common/accelerator_util.h"
 #include "services/ui/public/cpp/property_type_converters.h"
+#include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/accelerator_history.h"
 
 namespace ash {
 namespace mus {
 namespace {
 
+const ui::Accelerator kWindowCycleCompleteAccelerator(

[sky, 2017/03/29 22:00:57]

Style guide says statics (which include this) should only be POD (plain old
data). This is why we have structures like AcceleratorData. Make the two
accelerators members of AcceleratorControllerRegistrar.

Also, you shouldn't need to create an accelerator from a keyevent, create the
accelerator directly.

+    ui::KeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_MENU, 0));
+const ui::Accelerator kWindowCycleCancelAccelerator(ui::VKEY_ESCAPE,
+                                                    ui::EF_ALT_DOWN);
+
 // Callback from registering the accelerators.
 void OnAcceleratorsAdded(const std::vector<ui::Accelerator>& accelerators,
                          bool added) {
   // All our accelerators should be registered, so we expect |added| to be true.
   DCHECK(added) << "Unexpected accelerator vector registration failure.";
 }
 
 }  // namespace
 
 AcceleratorControllerRegistrar::AcceleratorControllerRegistrar(
     WindowManager* window_manager,
     uint16_t id_namespace)
     : window_manager_(window_manager),
       id_namespace_(id_namespace),
       next_id_(0),
       router_(new AcceleratorRouter) {
   window_manager_->AddAcceleratorHandler(id_namespace, this);
+  RegisterWindowCycleAccelerators();
 }
 
 AcceleratorControllerRegistrar::~AcceleratorControllerRegistrar() {
   window_manager_->RemoveAcceleratorHandler(id_namespace_);
 
   if (!window_manager_->window_manager_client())
     return;
 
   // TODO(sky): consider not doing this. If we assume the destructor is called
   // during shutdown, then this is unnecessary and results in a bunch of
@@ skipping 23 matching lines @@
   if (is_pre) {
     // TODO(sky): this does not exactly match ash code. In particular ash code
     // is called for *all* key events, where as this is only called for
     // registered accelerators. This means the previous accelerator isn't the
     // same as it was in ash. We need to figure out exactly what is needed of
     // previous accelerator so that we can either register for the right set of
     // accelerators, or make WS send the previous accelerator.
     // http://crbug.com/630683.
     accelerator_controller->accelerator_history()->StoreCurrentAccelerator(
         accelerator);
+    if (HandleWindowCycleAccelerator(accelerator))
+      return ui::mojom::EventResult::HANDLED;
     WmWindow* target_window = WmShell::Get()->GetFocusedWindow();
     if (!target_window)
       target_window = Shell::GetWmRootWindowForNewWindows();
     DCHECK(target_window);
     if (router_->ProcessAccelerator(target_window, *(event.AsKeyEvent()),
                                     accelerator)) {
       return ui::mojom::EventResult::HANDLED;
     }
     if (accelerator_controller->IsActionForAcceleratorEnabled(accelerator)) {
       // We do have an accelerator for the key. Set a property so that the real
@@ skipping 83 matching lines @@
 uint16_t AcceleratorControllerRegistrar::GetNextLocalAcceleratorId() {
   DCHECK_LT(ids_.size(), std::numeric_limits<uint16_t>::max());
   // Common case is we never wrap once, so this is typically cheap. Additionally
   // we expect there not to be too many accelerators.
   while (ids_.count(next_id_) > 0)
     ++next_id_;
   ids_.insert(next_id_);
   return next_id_++;
 }
 
+void AcceleratorControllerRegistrar::RegisterWindowCycleAccelerators() {
+  std::vector<ui::Accelerator> accelerators;
+  accelerators.push_back(kWindowCycleCompleteAccelerator);
+  accelerators.push_back(kWindowCycleCancelAccelerator);
+  OnAcceleratorsRegistered(accelerators);
+}
+
+bool AcceleratorControllerRegistrar::HandleWindowCycleAccelerator(
+    const ui::Accelerator& accelerator) {
+  ash::WindowCycleController* window_cycle_controller =
+      Shell::Get()->window_cycle_controller();
+  if (!window_cycle_controller->IsCycling())
+    return false;
+
+  if (accelerator == kWindowCycleCompleteAccelerator) {
+    window_cycle_controller->CompleteCycling();
+    return true;
+  }
+
+  if (accelerator == kWindowCycleCancelAccelerator) {
+    window_cycle_controller->CancelCycling();
+    return true;
+  }
+
+  return false;
+}
+
 }  // namespace mus
 }  // namespace ash