Adds ability for pre-target accelerators to not consume events

services/ui/ws/event_dispatcher.cc

 // Copyright 2015 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/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "services/ui/ws/accelerator.h"
@@ skipping 235 matching lines @@
   return true;
 }
 
 void EventDispatcher::RemoveAccelerator(uint32_t id) {
   auto it = accelerators_.find(id);
   // Clients may pass bogus ids.
   if (it != accelerators_.end())
     accelerators_.erase(it);
 }
 
-void EventDispatcher::ProcessEvent(const ui::Event& event) {
+void EventDispatcher::ProcessEvent(const ui::Event& event,
+                                   AcceleratorMatchPhase match_phase) {
+#if !defined(NDEBUG)
+  if (match_phase == AcceleratorMatchPhase::POST_ONLY) {
+    // POST_ONLY should always be preceeded by ANY with the same event.
+    DCHECK(previous_event_);
+    // Event doesn't define ==, so this compares the key fields.
+    DCHECK(event.type() == previous_event_->type() &&
+           event.time_stamp() == previous_event_->time_stamp() &&
+           event.flags() == previous_event_->flags());
+    DCHECK_EQ(previous_accelerator_match_phase_, AcceleratorMatchPhase::ANY);
+  }
+  previous_event_ = Event::Clone(event);
+  previous_accelerator_match_phase_ = match_phase;
+#endif
   if (event.IsKeyEvent()) {
     const ui::KeyEvent* key_event = event.AsKeyEvent();
-    if (event.type() == ui::ET_KEY_PRESSED && !key_event->is_char()) {
+    if (event.type() == ui::ET_KEY_PRESSED && !key_event->is_char() &&
+        match_phase == AcceleratorMatchPhase::ANY) {
       Accelerator* pre_target =
           FindAccelerator(*key_event, ui::mojom::AcceleratorPhase::PRE_TARGET);
       if (pre_target) {
-        delegate_->OnAccelerator(pre_target->id(), event);
+        delegate_->OnAccelerator(
+            pre_target->id(), event,
+            EventDispatcherDelegate::AcceleratorPhase::PRE);
         return;
       }
     }
-    ProcessKeyEvent(*key_event);
+    ProcessKeyEvent(*key_event, match_phase);
     return;
   }
 
   if (event.IsPointerEvent() || event.IsMouseWheelEvent()) {
     ProcessLocatedEvent(*event.AsLocatedEvent());
     return;
   }
 
   NOTREACHED();
 }
 
-void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event) {
+void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event,
+                                      AcceleratorMatchPhase match_phase) {
   Accelerator* post_target =
       FindAccelerator(event, ui::mojom::AcceleratorPhase::POST_TARGET);
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window) {
     // Assume key events are for the client area.
     const bool in_nonclient_area = false;
     const ClientSpecificId client_id =
         delegate_->GetEventTargetClientId(focused_window, in_nonclient_area);
     delegate_->DispatchInputEventToWindow(focused_window, client_id, event,
                                           post_target);
     return;
   }
   delegate_->OnEventTargetNotFound(event);
   if (post_target)
-    delegate_->OnAccelerator(post_target->id(), event);
+    delegate_->OnAccelerator(post_target->id(), event,
+                             EventDispatcherDelegate::AcceleratorPhase::POST);
 }
 
 void EventDispatcher::ProcessLocatedEvent(const ui::LocatedEvent& event) {
   DCHECK(event.IsPointerEvent() || event.IsMouseWheelEvent());
   const bool is_mouse_event =
       event.IsMousePointerEvent() || event.IsMouseWheelEvent();
 
   if (is_mouse_event) {
     mouse_pointer_last_location_ = event.location();
     delegate_->OnMouseCursorLocationChanged(event.root_location());
@@ skipping 198 matching lines @@
   if (!it->second) {
     window->RemoveObserver(this);
     observed_windows_.erase(it);
   }
 }
 
 Accelerator* EventDispatcher::FindAccelerator(
     const ui::KeyEvent& event,
     const ui::mojom::AcceleratorPhase phase) {
   for (const auto& pair : accelerators_) {
-    if (pair.second->MatchesEvent(event, phase)) {
+    if (pair.second->MatchesEvent(event, phase))
       return pair.second.get();
-    }
   }
   return nullptr;
 }
 
 ServerWindow* EventDispatcher::FindDeepestVisibleWindowForEvents(
     gfx::Point* location) {
   ServerWindow* root = delegate_->GetRootWindowContaining(*location);
   if (!root)
     return nullptr;
 
@@ skipping 23 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace ui