Adds ability for pre-target accelerators to not consume events

services/ui/ws/event_dispatcher.h

 // 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.
 
 #ifndef SERVICES_UI_WS_EVENT_DISPATCHER_H_
 #define SERVICES_UI_WS_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/event_matcher.mojom.h"
 #include "services/ui/ws/modal_window_controller.h"
 #include "services/ui/ws/server_window_observer.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace ui {
 class Event;
 class KeyEvent;
 class LocatedEvent;
-}
 
-namespace ui {
 namespace ws {
 
 class Accelerator;
 class EventDispatcherDelegate;
 class ServerWindow;
 
 namespace test {
 class EventDispatcherTestApi;
 }
 
 // Handles dispatching events to the right location as well as updating focus.
 class EventDispatcher : public ServerWindowObserver {
  public:
+  enum class AcceleratorMatchPhase {
+    // Both pre and post should be considered.
+    ANY,
+
+    // PRE_TARGETs are not considered, only the actual target and any
+    // accelerators registered with POST_TARGET.
+    POST_ONLY,
+  };
+
   explicit EventDispatcher(EventDispatcherDelegate* delegate);
   ~EventDispatcher() override;
 
   // Cancels capture and stops tracking any pointer events. This does not send
   // any events to the delegate.
   void Reset();
 
   void SetMousePointerScreenLocation(const gfx::Point& screen_location);
   const gfx::Point& mouse_pointer_last_location() const {
     return mouse_pointer_last_location_;
@@ skipping 46 matching lines @@
   // ServerWindow* under it.
   void UpdateCursorProviderByLastKnownLocation();
 
   // Adds an accelerator with the given id and event-matcher. If an accelerator
   // already exists with the same id or the same matcher, then the accelerator
   // is not added. Returns whether adding the accelerator was successful or not.
   bool AddAccelerator(uint32_t id, mojom::EventMatcherPtr event_matcher);
   void RemoveAccelerator(uint32_t id);
 
   // Processes the supplied event, informing the delegate as approriate. This
-  // may result in generating any number of events.
-  void ProcessEvent(const ui::Event& event);
+  // may result in generating any number of events. If |match_phase| is
+  // ANY and there is a matching accelerator with PRE_TARGET found, than only
+  // OnAccelerator() is called. The expectation is after the PRE_TARGET has been
+  // handled this is again called with an AcceleratorMatchPhase of POST_ONLY.
+  void ProcessEvent(const ui::Event& event, AcceleratorMatchPhase match_phase);
 
  private:
   friend class test::EventDispatcherTestApi;
 
   // Keeps track of state associated with an active pointer.
   struct PointerTarget {
     PointerTarget()
         : window(nullptr),
           is_mouse_event(false),
           in_nonclient_area(false),
           is_pointer_down(false) {}
 
     // NOTE: this is set to null if the window is destroyed before a
     // corresponding release/cancel.
     ServerWindow* window;
 
     bool is_mouse_event;
 
     // Did the pointer event start in the non-client area.
     bool in_nonclient_area;
 
     bool is_pointer_down;
   };
 
-  void ProcessKeyEvent(const ui::KeyEvent& event);
+  void ProcessKeyEvent(const ui::KeyEvent& event,
+                       AcceleratorMatchPhase match_phase);
 
   bool IsTrackingPointer(int32_t pointer_id) const {
     return pointer_targets_.count(pointer_id) > 0;
   }
 
   // EventDispatcher provides the following logic for pointer events:
   // . wheel events go to the current target of the associated pointer. If
   //   there is no target, they go to the deepest window.
   // . move (not drag) events go to the deepest window.
   // . when a pointer goes down all events until the corresponding up or
@@ skipping 76 matching lines @@
   using PointerIdToTargetMap = std::map<int32_t, PointerTarget>;
   // |pointer_targets_| contains the active pointers. For a mouse based pointer
   // a PointerTarget is always active (and present in |pointer_targets_|). For
   // touch based pointers the pointer is active while down and removed on
   // cancel or up.
   PointerIdToTargetMap pointer_targets_;
 
   // Keeps track of number of observe requests for each observed window.
   std::map<const ServerWindow*, uint8_t> observed_windows_;
 
+#if !defined(NDEBUG)
+  std::unique_ptr<ui::Event> previous_event_;
+  AcceleratorMatchPhase previous_accelerator_match_phase_ =
+      AcceleratorMatchPhase::ANY;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_EVENT_DISPATCHER_H_