Add AcceleratorType to EventMatcher

components/mus/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 "components/mus/ws/event_dispatcher.h"
 
 #include <set>
 
 #include "base/time/time.h"
 #include "cc/surfaces/surface_hittest.h"
@@ skipping 40 matching lines @@
 
   return true;
 }
 
 }  // namespace
 
 class EventMatcher {
  public:
   explicit EventMatcher(const mojom::EventMatcher& matcher)
       : fields_to_match_(NONE),
+        accelerator_phase_(mojom::AcceleratorPhase::PRE_TARGET),
         event_type_(ui::ET_UNKNOWN),
         event_flags_(ui::EF_NONE),
         ignore_event_flags_(ui::EF_NONE),
         keyboard_code_(ui::VKEY_UNKNOWN),
         pointer_type_(ui::EventPointerType::POINTER_TYPE_UNKNOWN) {
+    accelerator_phase_ = matcher.accelerator_phase;
     if (matcher.type_matcher) {
       fields_to_match_ |= TYPE;
       switch (matcher.type_matcher->type) {
         case mus::mojom::EventType::POINTER_DOWN:
           event_type_ = ui::ET_POINTER_DOWN;
           break;
         case mus::mojom::EventType::POINTER_MOVE:
           event_type_ = ui::ET_POINTER_MOVED;
           break;
         case mus::mojom::EventType::MOUSE_EXIT:
@@ skipping 41 matching lines @@
     }
     if (matcher.pointer_location_matcher) {
       fields_to_match_ |= POINTER_LOCATION;
       pointer_region_ =
           matcher.pointer_location_matcher->region.To<gfx::RectF>();
     }
   }
 
   ~EventMatcher() {}
 
-  bool MatchesEvent(const ui::Event& event) const {
+  bool MatchesEvent(const ui::Event& event,
+                    const mojom::AcceleratorPhase phase) const {
+    if (accelerator_phase_ != phase)
+      return false;
     if ((fields_to_match_ & TYPE) && event.type() != event_type_)
       return false;
     int flags = event.flags() & ~ignore_event_flags_;
     if ((fields_to_match_ & FLAGS) && flags != event_flags_)
       return false;
     if (fields_to_match_ & KEYBOARD_CODE) {
       if (!event.IsKeyEvent())
         return false;
       if (keyboard_code_ != event.AsKeyEvent()->GetConflatedWindowsKeyCode())
         return false;
     }
     if (fields_to_match_ & POINTER_KIND) {
       if (!event.IsPointerEvent() ||
           pointer_type_ !=
               event.AsPointerEvent()->pointer_details().pointer_type)
         return false;
     }
     if (fields_to_match_ & POINTER_LOCATION) {
       // TODO(sad): The tricky part here is to make sure the same coord-space is
       // used for the location-region and the event-location.
       NOTIMPLEMENTED();
       return false;
     }
 
     return true;
   }
 
   bool Equals(const EventMatcher& matcher) const {
     return fields_to_match_ == matcher.fields_to_match_ &&
+           accelerator_phase_ == matcher.accelerator_phase_ &&
            event_type_ == matcher.event_type_ &&
            event_flags_ == matcher.event_flags_ &&
            ignore_event_flags_ == matcher.ignore_event_flags_ &&
            keyboard_code_ == matcher.keyboard_code_ &&
            pointer_type_ == matcher.pointer_type_ &&
            pointer_region_ == matcher.pointer_region_;
   }
 
  private:
   enum MatchFields {
     NONE = 0,
     TYPE = 1 << 0,
     FLAGS = 1 << 1,
     KEYBOARD_CODE = 1 << 2,
     POINTER_KIND = 1 << 3,
     POINTER_LOCATION = 1 << 4,
   };
 
   uint32_t fields_to_match_;
+  mojom::AcceleratorPhase accelerator_phase_;
   ui::EventType event_type_;
   // Bitfields of kEventFlag* and kMouseEventFlag* values in
   // input_event_constants.mojom.
   int event_flags_;
   int ignore_event_flags_;
   uint16_t keyboard_code_;
   ui::EventPointerType pointer_type_;
   gfx::RectF pointer_region_;
 };
 
@@ skipping 103 matching lines @@
 }
 
 void EventDispatcher::ProcessEvent(const ui::Event& event) {
   if (!root_)
     return;
 
   if (event.IsKeyEvent()) {
     const ui::KeyEvent* key_event = event.AsKeyEvent();
     if (event.type() == ui::ET_KEY_PRESSED && !key_event->is_char()) {
       uint32_t accelerator = 0u;
-      if (FindAccelerator(*key_event, &accelerator)) {
+      if (FindAccelerator(*key_event, mojom::AcceleratorPhase::PRE_TARGET,
+                          &accelerator)) {
         delegate_->OnAccelerator(accelerator, event);
         return;
       }
     }
     ProcessKeyEvent(*key_event);
     return;
   }
 
   if (event.IsPointerEvent()) {
     ProcessPointerEvent(*event.AsPointerEvent());
@@ skipping 187 matching lines @@
 
 bool EventDispatcher::IsObservingWindow(ServerWindow* window) {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.window == window)
       return true;
   }
   return false;
 }
 
 bool EventDispatcher::FindAccelerator(const ui::KeyEvent& event,
+                                      const mojom::AcceleratorPhase phase,
                                       uint32_t* accelerator_id) {
   for (const auto& pair : accelerators_) {
-    if (pair.second.MatchesEvent(event)) {
+    if (pair.second.MatchesEvent(event, phase)) {
       *accelerator_id = pair.first;
       return true;
     }
   }
   return false;
 }
 
 void EventDispatcher::OnWillChangeWindowHierarchy(ServerWindow* window,
                                                   ServerWindow* new_parent,
                                                   ServerWindow* old_parent) {
   CancelPointerEventsToTarget(window);
 }
 
 void EventDispatcher::OnWindowVisibilityChanged(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 }
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus