Adds ability for pre-target accelerators to not consume events

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 413 matching lines @@
   } else {
     DVLOG(1) << "AddActivationParent supplied invalid window id";
   }
 }
 
 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) {
+                               const ui::Event& event,
+                               bool needs_ack) {
   DCHECK(window_manager_internal_);
+  const uint32_t ack_id = needs_ack ? GenerateEventAckId() : 0u;
   // TODO(moshayedi): crbug.com/617167. Don't clone even once we map
   // mojom::Event directly to ui::Event.
-  window_manager_internal_->OnAccelerator(accelerator_id,
+  window_manager_internal_->OnAccelerator(ack_id, accelerator_id,
                                           ui::Event::Clone(event));
 }
 
 void WindowTree::ClientJankinessChanged(WindowTree* tree) {
   tree->janky_ = !tree->janky_;
   if (window_manager_internal_) {
     window_manager_internal_->WmClientJankinessChanged(
         tree->id(), tree->janky());
   }
 }
@@ skipping 504 matching lines @@
   }
 }
 
 void WindowTree::RemoveChildrenAsPartOfEmbed(ServerWindow* window) {
   CHECK(window);
   std::vector<ServerWindow*> children = window->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     window->Remove(children[i]);
 }
 
+uint32_t WindowTree::GenerateEventAckId() {
+  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);

[dcheng, 2016/07/07 04:04:21]

Out of curiosity, are there/should there be any requirements around this not
being guessable, since it's passed back from a WindowTreeClient to the
WindowTree?

[sky, 2016/07/07 13:38:38]

I don't think it's been given much thought. If the client starts calling
OnWindowInputEventAck randomly we'll hit a NOTIMPLEMENTED on 1305. We need to
decide what the right handling is.

+  return event_ack_id_;
+}
+
 void WindowTree::DispatchInputEventImpl(ServerWindow* target,
                                         const ui::Event& event) {
-  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.
-  // TODO(moshayedi): Find a faster way to generate ids.
-  event_ack_id_ = 0x1000000 | (rand() & 0xffffff);
+  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_observer =
       event_observer_matcher_ && event_observer_matcher_->MatchesEvent(event);
   client()->OnWindowInputEvent(
       event_ack_id_, ClientWindowIdForWindow(target).id,
       ui::Event::Clone(event), matched_observer ? event_observer_id_ : 0);
@@ skipping 309 matching lines @@
     if (display)
       display->SetImeVisibility(window, visible);
   }
 }
 
 void WindowTree::OnWindowInputEventAck(uint32_t event_id,
                                        mojom::EventResult result) {
   if (event_ack_id_ == 0 || event_id != event_ack_id_) {
     // TODO(sad): Something bad happened. Kill the client?
     NOTIMPLEMENTED() << "Wrong event acked.";
+    DVLOG(1) << "OnAcceleratorAck supplied unexpected event_id";
   }
   event_ack_id_ = 0;
 
   if (janky_)
     event_source_wms_->window_tree()->ClientJankinessChanged(this);
 
   WindowManagerState* event_source_wms = event_source_wms_;
   event_source_wms_ = nullptr;
   if (event_source_wms)
     event_source_wms->OnEventAck(this, result);
@@ skipping 203 matching lines @@
   ServerWindow* window =
       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) {
+  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);
+}
+
 bool WindowTree::HasRootForAccessPolicy(const ServerWindow* window) const {
   return HasRoot(window);
 }
 
 bool WindowTree::IsWindowKnownForAccessPolicy(
     const ServerWindow* window) const {
   return IsWindowKnown(window);
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace ui