Changes accelerators registered by mus to not interfere with those of client

services/ui/ws/window_manager_state.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 "services/ui/ws/window_manager_state.h"
 
 #include "base/memory/weak_ptr.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "services/ui/common/event_matcher_util.h"
 #include "services/ui/ws/accelerator.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/platform_display.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/user_display_manager.h"
 #include "services/ui/ws/user_id_tracker.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_tree.h"
 #include "ui/events/event.h"
 
 namespace ui {
 namespace ws {
 namespace {
 
-// Debug accelerator IDs start far above the highest valid Windows command ID
-// (0xDFFF) and Chrome's highest IDC command ID.
-const uint32_t kPrintWindowsDebugAcceleratorId = 1u << 31;
-
 base::TimeDelta GetDefaultAckTimerDelay() {
 #if defined(NDEBUG)
   return base::TimeDelta::FromMilliseconds(100);
 #else
   return base::TimeDelta::FromMilliseconds(1000);
 #endif
 }
 
 bool EventsCanBeCoalesced(const ui::Event& one, const ui::Event& two) {
   if (one.type() != two.type() || one.flags() != two.flags())
@@ skipping 154 matching lines @@
     if (!event_queue_.empty() && !event_queue_.back()->processed_target &&
         EventsCanBeCoalesced(*event_queue_.back()->event, event)) {
       event_queue_.back()->event = CoalesceEvents(
           std::move(event_queue_.back()->event), ui::Event::Clone(event));
       return;
     }
     QueueEvent(event, nullptr);
     return;
   }
 
-  event_dispatcher_.ProcessEvent(event,
-                                 EventDispatcher::AcceleratorMatchPhase::ANY);
+  ProcessEventImpl(event);
 }
 
 void WindowManagerState::OnEventAck(mojom::WindowTree* tree,
                                     mojom::EventResult result) {
   if (tree_awaiting_input_ack_ != tree ||
       event_dispatch_phase_ != EventDispatchPhase::TARGET) {
     // TODO(sad): The ack must have arrived after the timeout. We should do
     // something here, and in OnEventAckTimeout().
     return;
   }
@@ skipping 75 matching lines @@
 void WindowManagerState::OnEventAckTimeout(ClientSpecificId client_id) {
   WindowTree* hung_tree = window_server()->GetTreeWithId(client_id);
   if (hung_tree && !hung_tree->janky())
     window_tree_->ClientJankinessChanged(hung_tree);
   if (event_dispatch_phase_ == EventDispatchPhase::PRE_TARGET_ACCELERATOR)
     OnAcceleratorAck(mojom::EventResult::UNHANDLED);
   else
     OnEventAck(tree_awaiting_input_ack_, mojom::EventResult::UNHANDLED);
 }
 
+void WindowManagerState::ProcessEventImpl(const ui::Event& event) {
+  // Debug accelerators are always checked and don't interfere with processing.
+  ProcessDebugAccelerator(event);
+  event_dispatcher_.ProcessEvent(event,
+                                 EventDispatcher::AcceleratorMatchPhase::ANY);
+}
+
 void WindowManagerState::QueueEvent(
     const ui::Event& event,
     std::unique_ptr<ProcessedEventTarget> processed_event_target) {
   std::unique_ptr<QueuedEvent> queued_event(new QueuedEvent);
   queued_event->event = ui::Event::Clone(event);
   queued_event->processed_target = std::move(processed_event_target);
   event_queue_.push(std::move(queued_event));
 }
 
 void WindowManagerState::ProcessNextEventFromQueue() {
   // Loop through |event_queue_| stopping after dispatching the first valid
   // event.
   while (!event_queue_.empty()) {
     std::unique_ptr<QueuedEvent> queued_event = std::move(event_queue_.front());
     event_queue_.pop();
     if (!queued_event->processed_target) {
-      event_dispatcher_.ProcessEvent(
-          *queued_event->event, EventDispatcher::AcceleratorMatchPhase::ANY);
+      ProcessEventImpl(*queued_event->event);
       return;
     }
     if (queued_event->processed_target->IsValid()) {
       DispatchInputEventToWindowImpl(
           queued_event->processed_target->window(),
           queued_event->processed_target->client_id(), *queued_event->event,
           queued_event->processed_target->accelerator());
       return;
     }
   }
@@ skipping 29 matching lines @@
     post_target_accelerator_ = accelerator;
   }
 
   // Ignore |tree| because it will receive the event via normal dispatch.
   window_server()->SendToEventObservers(event, user_id(), tree);
 
   tree->DispatchInputEvent(target, event);
 }
 
 void WindowManagerState::AddDebugAccelerators() {
-  // Always register the accelerators, even if they only work in debug, so that
-  // keyboard behavior is the same in release and debug builds.
-  mojom::EventMatcherPtr matcher = CreateKeyMatcher(
-      ui::mojom::KeyboardCode::S, ui::mojom::kEventFlagControlDown |
-                                      ui::mojom::kEventFlagAltDown |
-                                      ui::mojom::kEventFlagShiftDown);
-  event_dispatcher_.AddAccelerator(kPrintWindowsDebugAcceleratorId,
-                                   std::move(matcher));
+  const DebugAccelerator accelerator = {
+      DebugAcceleratorType::PRINT_WINDOWS, ui::VKEY_S,
+      ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | ui::EF_SHIFT_DOWN};
+  debug_accelerators_.push_back(accelerator);
 }
 
-bool WindowManagerState::HandleDebugAccelerator(uint32_t accelerator_id) {
+void WindowManagerState::ProcessDebugAccelerator(const ui::Event& event) {
+  if (event.type() != ui::ET_KEY_PRESSED)
+    return;
+
+  const ui::KeyEvent& key_event = *event.AsKeyEvent();
+  for (const DebugAccelerator& accelerator : debug_accelerators_) {
+    if (accelerator.key_code == key_event.key_code() &&
+        accelerator.event_flags == key_event.flags()) {
+      HandleDebugAccelerator(accelerator.type);
+      break;
+    }
+  }
+}
+
+void WindowManagerState::HandleDebugAccelerator(DebugAcceleratorType type) {
 #if !defined(NDEBUG)
-  if (accelerator_id == kPrintWindowsDebugAcceleratorId) {
-    // Error so it will be collected in system logs.
-    for (Display* display : display_manager()->displays()) {
-      WindowManagerDisplayRoot* display_root =
-          display->GetWindowManagerDisplayRootForUser(user_id());
-      if (display_root) {
-        LOG(ERROR) << "ServerWindow hierarchy:\n"
-                   << display_root->root()->GetDebugWindowHierarchy();
-      }
+  // Error so it will be collected in system logs.
+  for (Display* display : display_manager()->displays()) {
+    WindowManagerDisplayRoot* display_root =
+        display->GetWindowManagerDisplayRootForUser(user_id());
+    if (display_root) {
+      LOG(ERROR) << "ServerWindow hierarchy:\n"
+                 << display_root->root()->GetDebugWindowHierarchy();
     }
-    return true;
   }
 #endif
-  return false;
 }
 
 void WindowManagerState::ScheduleInputEventTimeout(WindowTree* tree) {
   // TOOD(sad): Adjust this delay, possibly make this dynamic.
   const base::TimeDelta max_delay = base::debug::BeingDebugged()
                                         ? base::TimeDelta::FromDays(1)
                                         : GetDefaultAckTimerDelay();
   event_ack_timer_.Start(FROM_HERE, max_delay,
                          base::Bind(&WindowManagerState::OnEventAckTimeout,
                                     weak_factory_.GetWeakPtr(), tree->id()));
 
   tree_awaiting_input_ack_ = tree;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // EventDispatcherDelegate:
 
 void WindowManagerState::OnAccelerator(uint32_t accelerator_id,
                                        const ui::Event& event,
                                        AcceleratorPhase phase) {
   DCHECK(IsActive());
-  if (HandleDebugAccelerator(accelerator_id))
-    return;
   const bool needs_ack = phase == AcceleratorPhase::PRE;
   if (needs_ack) {
     DCHECK_EQ(EventDispatchPhase::NONE, event_dispatch_phase_);
     event_dispatch_phase_ = EventDispatchPhase::PRE_TARGET_ACCELERATOR;
     event_awaiting_input_ack_ = ui::Event::Clone(event);
     ScheduleInputEventTimeout(window_tree_);
   }
   window_tree_->OnAccelerator(accelerator_id, event, needs_ack);
 }
 
@@ skipping 103 matching lines @@
   return display_root ? display_root->root() : nullptr;
 }
 
 void WindowManagerState::OnEventTargetNotFound(const ui::Event& event) {
   window_server()->SendToEventObservers(event, user_id(),
                                         nullptr /* ignore_tree */);
 }
 
 }  // namespace ws
 }  // namespace ui