Adds ability for pre-target accelerators to not consume events

services/ui/ws/window_manager_state_unittest.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 <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 35 matching lines @@
   // |test_client|. The window is setup for processing input.
   void CreateSecondaryTree(TestWindowTreeClient** test_client,
                            WindowTree** window_tree,
                            ServerWindow** server_window);
 
   void DispatchInputEventToWindow(ServerWindow* target,
                                   const ui::Event& event,
                                   Accelerator* accelerator);
   void OnEventAckTimeout(ClientSpecificId client_id);
 
+  // This is the tree associated with the WindowManagerState.
   WindowTree* tree() {
     return window_event_targeting_helper_.window_server()->GetTreeWithId(1);
   }
+  // This is *not* the tree associated with the WindowManagerState, use tree()
+  // if you need the window manager tree.
   WindowTree* window_tree() { return window_tree_; }
   TestWindowTreeClient* window_tree_client() { return window_tree_client_; }
   ServerWindow* window() { return window_; }
   TestWindowManager* window_manager() { return &window_manager_; }
   TestWindowTreeClient* wm_client() {
     return window_event_targeting_helper_.wm_client();
   }
   TestWindowTreeClient* last_tree_client() {
     return window_event_targeting_helper_.last_window_tree_client();
   }
@@ skipping 85 matching lines @@
   window_tree_ = window_event_targeting_helper_.last_binding()->tree();
   window_tree_client_ =
       window_event_targeting_helper_.last_window_tree_client();
   DCHECK(window_tree_->HasRoot(window_));
 
   WindowTreeTestApi(tree()).set_window_manager_internal(&window_manager_);
   wm_client()->tracker()->changes()->clear();
   window_tree_client_->tracker()->changes()->clear();
 }
 
+void SetCanFocusUp(ServerWindow* window) {
+  while (window) {
+    window->set_can_focus(true);
+    window = window->parent();
+  }
+}
+
 // Tests that when an event is dispatched with no accelerator, that post target
 // accelerator is not triggered.
 TEST_F(WindowManagerStateTest, NullAccelerator) {
   WindowManagerState* state = window_manager_state();
   EXPECT_TRUE(state);
 
   ServerWindow* target = window();
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   DispatchInputEventToWindow(target, key, nullptr);
   WindowTree* target_tree = window_tree();
@@ skipping 17 matching lines @@
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   WindowTreeTestApi(window_tree()).AckOldestEvent();
   EXPECT_TRUE(window_manager()->on_accelerator_called());
   EXPECT_EQ(accelerator->id(), window_manager()->on_accelerator_id());
 }
 
+// Tests that if a pre target accelerator consumes the event no other processing
+// is done.
+TEST_F(WindowManagerStateTest, PreTargetConsumed) {
+  // Set up two trees with focus on a child in the second.
+  const ClientWindowId child_window_id(11);
+  window_tree()->NewWindow(child_window_id, ServerWindow::Properties());
+  ServerWindow* child_window =
+      window_tree()->GetWindowByClientId(child_window_id);
+  window_tree()->AddWindow(FirstRootId(window_tree()), child_window_id);
+  child_window->SetVisible(true);
+  SetCanFocusUp(child_window);
+  tree()->GetDisplay(child_window)->AddActivationParent(child_window->parent());
+  ASSERT_TRUE(window_tree()->SetFocus(child_window_id));
+
+  // Register a pre-accelerator.
+  uint32_t accelerator_id = 11;
+  {
+    mojom::EventMatcherPtr matcher = ui::CreateKeyMatcher(
+        ui::mojom::KeyboardCode::W, ui::mojom::kEventFlagControlDown);
+    ASSERT_TRUE(window_manager_state()->event_dispatcher()->AddAccelerator(
+        accelerator_id, std::move(matcher)));
+  }
+  TestChangeTracker* tracker = wm_client()->tracker();
+  tracker->changes()->clear();
+  TestChangeTracker* tracker2 = window_tree_client()->tracker();
+  tracker2->changes()->clear();
+
+  // Send an ensure only the pre accelerator is called.
+  ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
+  window_manager_state()->ProcessEvent(key);
+  EXPECT_TRUE(window_manager()->on_accelerator_called());
+  EXPECT_EQ(accelerator_id, window_manager()->on_accelerator_id());
+  EXPECT_TRUE(tracker->changes()->empty());
+  EXPECT_TRUE(tracker2->changes()->empty());
+
+  // Ack the accelerator, saying we consumed it.
+  WindowTreeTestApi(tree()).AckLastAccelerator(mojom::EventResult::HANDLED);
+  // Nothing should change.
+  EXPECT_TRUE(tracker->changes()->empty());
+  EXPECT_TRUE(tracker2->changes()->empty());
+
+  window_manager()->ClearAcceleratorCalled();
+
+  // Repeat, but respond with UNHANDLED.
+  window_manager_state()->ProcessEvent(key);
+  EXPECT_TRUE(window_manager()->on_accelerator_called());
+  EXPECT_EQ(accelerator_id, window_manager()->on_accelerator_id());
+  EXPECT_TRUE(tracker->changes()->empty());
+  EXPECT_TRUE(tracker2->changes()->empty());
+  WindowTreeTestApi(tree()).AckLastAccelerator(mojom::EventResult::UNHANDLED);
+
+  EXPECT_TRUE(tracker->changes()->empty());
+  // The focused window should get the event.
+  EXPECT_EQ("InputEvent window=0,11 event_action=7",
+            SingleChangeToDescription(*tracker2->changes()));
+}
+
 // Tests that when a client handles an event that post target accelerators are
 // not called.
 TEST_F(WindowManagerStateTest, ClientHandlesEvent) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
 
   ServerWindow* target = window();
   DispatchInputEventToWindow(target, key, accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
@@ skipping 199 matching lines @@
     EXPECT_EQ(CHANGE_TYPE_INPUT_EVENT,
               (*embedder_client->tracker()->changes())[0].type);
     WindowTreeTestApi(embedder_tree)
         .AckLastEvent(mojom::EventResult::UNHANDLED);
   }
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui