mus: Add EventObserver to allow passively listening to UI events

components/mus/ws/event_dispatcher_unittest.cc

 // Copyright 2015 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 "components/mus/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "components/mus/public/cpp/event_matcher.h"
+#include "components/mus/public/cpp/event_matcher_util.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_surface_manager_test_api.h"
 #include "components/mus/ws/test_server_window_delegate.h"
 #include "components/mus/ws/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 
 namespace mus {
@@ skipping 14 matching lines @@
 
 class TestEventDispatcherDelegate : public EventDispatcherDelegate {
  public:
   explicit TestEventDispatcherDelegate(ServerWindow* root)
       : root_(root),
         focused_window_(nullptr),
         lost_capture_window_(nullptr),
         last_accelerator_(0) {}
   ~TestEventDispatcherDelegate() override {}
 
+  ui::Event* last_event_target_not_found() {
+    return last_event_target_not_found_.get();
+  }
+
   uint32_t GetAndClearLastAccelerator() {
     uint32_t return_value = last_accelerator_;
     last_accelerator_ = 0;
     return return_value;
   }
 
   // Returns the last dispatched event, or null if there are no more.
   std::unique_ptr<DispatchedEventDetails>
   GetAndAdvanceDispatchedEventDetails() {
     if (dispatched_event_queue_.empty())
@@ skipping 37 matching lines @@
                                   bool in_nonclient_area,
                                   const ui::Event& event,
                                   Accelerator* accelerator) override {
     std::unique_ptr<DispatchedEventDetails> details(new DispatchedEventDetails);
     details->window = target;
     details->in_nonclient_area = in_nonclient_area;
     details->event = ui::Event::Clone(event);
     details->accelerator = accelerator;
     dispatched_event_queue_.push(std::move(details));
   }
+  void OnEventTargetNotFound(const ui::Event& event) override {
+    last_event_target_not_found_ = ui::Event::Clone(event);
+  }
 
   ServerWindow* root_;
   ServerWindow* focused_window_;
   ServerWindow* lost_capture_window_;
   uint32_t last_accelerator_;
   std::queue<std::unique_ptr<DispatchedEventDetails>> dispatched_event_queue_;
+  std::unique_ptr<ui::Event> last_event_target_not_found_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventDispatcherDelegate);
 };
 
 // Used by RunMouseEventTests(). Can identify up to two generated events. The
 // first ServerWindow and two points identify the first event, the second
 // ServerWindow and points identify the second event. If only one event is
 // generated set the second window to null.
 struct MouseEventTest {
   ui::MouseEvent input_event;
@@ skipping 168 matching lines @@
   ASSERT_EQ(child.get(), details->window);
 
   ASSERT_TRUE(details->event);
   ASSERT_TRUE(details->event->IsPointerEvent());
 
   ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
   EXPECT_EQ(gfx::Point(20, 25), dispatched_event->root_location());
   EXPECT_EQ(gfx::Point(10, 15), dispatched_event->location());
 }
 
+TEST_F(EventDispatcherTest, ProcessEventNoTarget) {
+  // Send event without a target.
+  ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE);
+  event_dispatcher()->ProcessEvent(key);
+
+  // Event wasn't dispatched to a target.
+  std::unique_ptr<DispatchedEventDetails> details =
+      test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
+  EXPECT_FALSE(details);
+
+  // Delegate was informed that there wasn't a target.
+  ui::Event* event_out =
+      test_event_dispatcher_delegate()->last_event_target_not_found();
+  ASSERT_TRUE(event_out);
+  EXPECT_TRUE(event_out->IsKeyEvent());
+  EXPECT_EQ(ui::VKEY_A, event_out->AsKeyEvent()->key_code());
+}
+
 TEST_F(EventDispatcherTest, AcceleratorBasic) {
   ClearSetup();
   TestEventDispatcherDelegate event_dispatcher_delegate(nullptr);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
 
   uint32_t accelerator_1 = 1;
   mojom::EventMatcherPtr matcher = mus::CreateKeyMatcher(
       mus::mojom::KeyboardCode::W, mus::mojom::kEventFlagControlDown);
   EXPECT_TRUE(dispatcher.AddAccelerator(accelerator_1, std::move(matcher)));
 
@@ skipping 1027 matching lines @@
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   EXPECT_TRUE(event_dispatcher()->SetCaptureWindow(w3.get(), false));
   EXPECT_EQ(w3.get(), event_dispatcher()->capture_window());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus