Adds ability for accelerators to add key/value pairs to KeyEvent

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 <utility>
 
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 280 matching lines @@
   post_target_accelerator_.reset();
 
   if (result == mojom::EventResult::UNHANDLED && post_target_accelerator) {
     OnAccelerator(post_target_accelerator->id(), *details->event,
                   AcceleratorPhase::POST);
   }
 
   ProcessNextEventFromQueue();
 }
 
-void WindowManagerState::OnAcceleratorAck(mojom::EventResult result) {
+void WindowManagerState::OnAcceleratorAck(
+    mojom::EventResult result,
+    const std::unordered_map<std::string, std::vector<uint8_t>>& properties) {
   if (!in_flight_event_details_ ||
       in_flight_event_details_->phase !=
           EventDispatchPhase::PRE_TARGET_ACCELERATOR) {
     // TODO(sad): The ack must have arrived after the timeout. We should do
     // something here, and in OnEventAckTimeout().
     return;
   }
 
   std::unique_ptr<InFlightEventDetails> details =
       std::move(in_flight_event_details_);
 
   if (result == mojom::EventResult::UNHANDLED) {
+    DCHECK(details->event->IsKeyEvent());
+    if (!properties.empty())
+      details->event->AsKeyEvent()->SetProperties(properties);
     event_processing_display_id_ = details->display_id;
     event_dispatcher_.ProcessEvent(
         *details->event, 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()->SendToPointerWatchers(*details->event, user_id(), nullptr,
                                            nullptr, details->display_id);
     ProcessNextEventFromQueue();
   }
@@ skipping 50 matching lines @@
   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);
   if (in_flight_event_details_->phase ==
       EventDispatchPhase::PRE_TARGET_ACCELERATOR) {
-    OnAcceleratorAck(mojom::EventResult::UNHANDLED);
+    OnAcceleratorAck(mojom::EventResult::UNHANDLED, KeyEvent::Properties());
   } else {
     OnEventAck(
         in_flight_event_details_ ? in_flight_event_details_->tree : nullptr,
         mojom::EventResult::UNHANDLED);
   }
 }
 
 void WindowManagerState::ProcessEventImpl(const ui::Event& event,
                                           int64_t display_id) {
   // Debug accelerators are always checked and don't interfere with processing.
@@ skipping 276 matching lines @@
       window->RemoveObserver(this);
       orphaned_window_manager_display_roots_.erase(iter);
       return;
     }
   }
   NOTREACHED();
 }
 
 }  // namespace ws
 }  // namespace ui