Adds ability for pre-target accelerators to not consume events

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"
@@ skipping 181 matching lines @@
   if (event_ack_timer_.IsRunning()) {
     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);
+
+  event_dispatcher_.ProcessEvent(event,
+                                 EventDispatcher::AcceleratorMatchPhase::ANY);
 }
 
 void WindowManagerState::OnEventAck(mojom::WindowTree* tree,
                                     mojom::EventResult result) {
-  if (tree_awaiting_input_ack_ != tree) {
+  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;
   }
   tree_awaiting_input_ack_ = nullptr;
   event_ack_timer_.Stop();
 
-  if (result == mojom::EventResult::UNHANDLED && post_target_accelerator_)
-    OnAccelerator(post_target_accelerator_->id(), *event_awaiting_input_ack_);
+  if (result == mojom::EventResult::UNHANDLED && post_target_accelerator_) {
+    OnAccelerator(post_target_accelerator_->id(), *event_awaiting_input_ack_,
+                  AcceleratorPhase::POST);
+  }
 
+  event_dispatch_phase_ = EventDispatchPhase::NONE;
   ProcessNextEventFromQueue();
 }
 
+void WindowManagerState::OnAcceleratorAck(mojom::EventResult result) {
+  if (event_dispatch_phase_ != EventDispatchPhase::PRE_TARGET_ACCELERATOR) {
+    // TODO(sad): The ack must have arrived after the timeout. We should do
+    // something here, and in OnEventAckTimeout().
+    return;
+  }
+
+  tree_awaiting_input_ack_ = nullptr;
+  event_ack_timer_.Stop();
+  event_dispatch_phase_ = EventDispatchPhase::NONE;
+
+  if (result == mojom::EventResult::UNHANDLED) {
+    event_dispatcher_.ProcessEvent(
+        *event_awaiting_input_ack_,
+        EventDispatcher::AcceleratorMatchPhase::POST_ONLY);
+  } else {
+    // We're not going to process the event any further, notify event observers.
+    // We don't do this first to ensure we don't send an event twice to clients.
+    window_server()->SendToEventObservers(*event_awaiting_input_ack_, user_id(),
+                                          nullptr);
+    ProcessNextEventFromQueue();
+  }
+}
+
 const WindowServer* WindowManagerState::window_server() const {
   return window_tree_->window_server();
 }
 
 WindowServer* WindowManagerState::window_server() {
   return window_tree_->window_server();
 }
 
 DisplayManager* WindowManagerState::display_manager() {
   return window_tree_->display_manager();
@@ skipping 20 matching lines @@
       return display_root->root();
   }
   NOTREACHED();
   return nullptr;
 }
 
 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);
-  OnEventAck(tree_awaiting_input_ack_, mojom::EventResult::UNHANDLED);
+  if (event_dispatch_phase_ == EventDispatchPhase::PRE_TARGET_ACCELERATOR)
+    OnAcceleratorAck(mojom::EventResult::UNHANDLED);
+  else
+    OnEventAck(tree_awaiting_input_ack_, mojom::EventResult::UNHANDLED);
 }
 
 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);
+      event_dispatcher_.ProcessEvent(
+          *queued_event->event, EventDispatcher::AcceleratorMatchPhase::ANY);
       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 11 matching lines @@
     DCHECK(event_dispatcher_.mouse_cursor_source_window());
 
     int32_t cursor_id = 0;
     if (event_dispatcher_.GetCurrentMouseCursor(&cursor_id)) {
       WindowManagerDisplayRoot* display_root =
           display_manager()->GetWindowManagerDisplayRoot(target);
       display_root->display()->UpdateNativeCursor(cursor_id);
     }
   }
 
+  event_dispatch_phase_ = EventDispatchPhase::TARGET;
+
   WindowTree* tree = window_server()->GetTreeWithId(client_id);
 
-  // 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()));
+  ScheduleInputEventTimeout(tree);
 
-  tree_awaiting_input_ack_ = tree;
   if (accelerator) {
     event_awaiting_input_ack_ = ui::Event::Clone(event);
     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);
 }
@@ skipping 20 matching lines @@
         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) {
+                                       const ui::Event& event,
+                                       AcceleratorPhase phase) {
   DCHECK(IsActive());
   if (HandleDebugAccelerator(accelerator_id))
     return;
-  window_tree_->OnAccelerator(accelerator_id, event);
+  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);
 }
 
 void WindowManagerState::SetFocusedWindowFromEventDispatcher(
     ServerWindow* new_focused_window) {
   DCHECK(IsActive());
   window_server()->SetFocusedWindow(new_focused_window);
 }
 
 ServerWindow* WindowManagerState::GetFocusedWindowForEventDispatcher() {
   return window_server()->GetFocusedWindow();
@@ skipping 93 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