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

services/ui/ws/window_tree.cc

 // Copyright 2014 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_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 17 matching lines @@
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_tree_binding.h"
 #include "ui/display/display.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/platform_window/mojo/ime_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
 using mojo::InterfaceRequest;
 
+using EventProperties = std::unordered_map<std::string, std::vector<uint8_t>>;
+
 namespace ui {
 namespace ws {
 
 class TargetedEvent : public ServerWindowObserver {
  public:
   TargetedEvent(ServerWindow* target, const ui::Event& event)
       : target_(target), event_(ui::Event::Clone(event)) {
     target_->AddObserver(this);
   }
   ~TargetedEvent() override {
@@ skipping 500 matching lines @@
   }
 }
 
 void WindowTree::OnChangeCompleted(uint32_t change_id, bool success) {
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::OnAccelerator(uint32_t accelerator_id,
                                const ui::Event& event,
                                bool needs_ack) {
+  DVLOG(3) << "OnAccelerator client=" << id_;
   DCHECK(window_manager_internal_);
   if (needs_ack)
     GenerateEventAckId();
   else
     DCHECK_EQ(0u, event_ack_id_);
   // TODO(moshayedi): crbug.com/617167. Don't clone even once we map
   // mojom::Event directly to ui::Event.
   window_manager_internal_->OnAccelerator(event_ack_id_, accelerator_id,
                                           ui::Event::Clone(event));
 }
@@ skipping 602 matching lines @@
   DCHECK(!event_ack_id_);
   // We do not want to create a sequential id for each event, because that can
   // leak some information to the client. So instead, manufacture the id
   // randomly.
   event_ack_id_ = 0x1000000 | (rand() & 0xffffff);
   return event_ack_id_;
 }
 
 void WindowTree::DispatchInputEventImpl(ServerWindow* target,
                                         const ui::Event& event) {
+  DVLOG(3) << "DispatchInputEventImpl client=" << id_;
   GenerateEventAckId();
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(target);
   DCHECK(display_root);
   event_source_wms_ = display_root->window_manager_state();
   // Should only get events from windows attached to a host.
   DCHECK(event_source_wms_);
   bool matched_pointer_watcher = EventMatchesPointerWatcher(event);
   Display* display = GetDisplay(target);
   DCHECK(display);
   client()->OnWindowInputEvent(
@@ skipping 303 matching lines @@
       window->SetTextInputState(state.To<ui::TextInputState>());
 
     Display* display = GetDisplay(window);
     if (display)
       display->SetImeVisibility(window, visible);
   }
 }
 
 void WindowTree::OnWindowInputEventAck(uint32_t event_id,
                                        mojom::EventResult result) {
+  DVLOG(3) << "OnWindowInputEventAck client=" << id_;
   if (event_ack_id_ == 0 || event_id != event_ack_id_) {
     // TODO(sad): Something bad happened. Kill the client?
     NOTIMPLEMENTED() << ": Wrong event acked. event_id=" << event_id
                      << ", event_ack_id_=" << event_ack_id_;
     DVLOG(1) << "OnWindowInputEventAck supplied unexpected event_id";
   }
   event_ack_id_ = 0;
 
   if (janky_)
     event_source_wms_->window_tree()->ClientJankinessChanged(this);
@@ skipping 553 matching lines @@
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window && window->id().client_id != id_) {
     DVLOG(1) << "OnWmCreatedTopLevelWindow supplied invalid window id";
     window_server_->WindowManagerSentBogusMessage();
     window = nullptr;
   }
   window_server_->WindowManagerCreatedTopLevelWindow(this, change_id, window);
 }
 
 void WindowTree::OnAcceleratorAck(uint32_t event_id,
-                                  mojom::EventResult result) {
+                                  mojom::EventResult result,
+                                  const EventProperties& properties) {
+  DVLOG(3) << "OnAcceleratorAck client=" << id_;
   if (event_ack_id_ == 0 || event_id != event_ack_id_) {
     DVLOG(1) << "OnAcceleratorAck supplied invalid event_id";
     window_server_->WindowManagerSentBogusMessage();
     return;
   }
   event_ack_id_ = 0;
   DCHECK(window_manager_state_);
-  window_manager_state_->OnAcceleratorAck(result);
+  window_manager_state_->OnAcceleratorAck(result, properties);
 }
 
 bool WindowTree::HasRootForAccessPolicy(const ServerWindow* window) const {
   return HasRoot(window);
 }
 
 bool WindowTree::IsWindowKnownForAccessPolicy(
     const ServerWindow* window) const {
   return IsWindowKnown(window);
 }
@@ skipping 111 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui