mus: Add EventObserver to allow passively listening to UI events

components/mus/ws/event_dispatcher.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 <set>
 
 #include "base/time/time.h"
 #include "cc/surfaces/surface_hittest.h"
@@ skipping 178 matching lines @@
 }
 
 void EventDispatcher::RemoveAccelerator(uint32_t id) {
   auto it = accelerators_.find(id);
   // Clients may pass bogus ids.
   if (it != accelerators_.end())
     accelerators_.erase(it);
 }
 
 void EventDispatcher::ProcessEvent(const ui::Event& event) {
-  if (!root_)
+  if (!root_)  // Tests may not have a root window.
     return;
 
   if (event.IsKeyEvent()) {
     const ui::KeyEvent* key_event = event.AsKeyEvent();
     if (event.type() == ui::ET_KEY_PRESSED && !key_event->is_char()) {
       Accelerator* pre_target =
           FindAccelerator(*key_event, mojom::AcceleratorPhase::PRE_TARGET);
       if (pre_target) {
         delegate_->OnAccelerator(pre_target->id(), event);
         return;
@@ skipping 12 matching lines @@
 }
 
 void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event) {
   Accelerator* post_target =
       FindAccelerator(event, mojom::AcceleratorPhase::POST_TARGET);
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window) {
     delegate_->DispatchInputEventToWindow(focused_window, false, event,
                                           post_target);
-  } else if (post_target) {
+    return;
+  }
+  delegate_->OnEventTargetNotFound(event);
+  if (post_target)
     delegate_->OnAccelerator(post_target->id(), event);
-  }
 }
 
 void EventDispatcher::ProcessLocatedEvent(const ui::LocatedEvent& event) {
   DCHECK(event.IsPointerEvent() || event.IsMouseWheelEvent());
   const bool is_mouse_event =
       event.IsMousePointerEvent() || event.IsMouseWheelEvent();
 
   if (is_mouse_event)
     mouse_pointer_last_location_ = event.location();
 
@@ skipping 128 matching lines @@
 bool EventDispatcher::AreAnyPointersDown() const {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.is_pointer_down)
       return true;
   }
   return false;
 }
 
 void EventDispatcher::DispatchToPointerTarget(const PointerTarget& target,
                                               const ui::LocatedEvent& event) {
-  if (!target.window)
+  if (!target.window) {
+    delegate_->OnEventTargetNotFound(event);
     return;
+  }
 
   gfx::Point location(event.location());
   gfx::Transform transform(GetTransformToWindow(surface_id_, target.window));
   transform.TransformPoint(&location);
   std::unique_ptr<ui::Event> clone = ui::Event::Clone(event);
   clone->AsLocatedEvent()->set_location(location);
   // TODO(jonross): add post-target accelerator support once accelerators
   // support pointer events.
   delegate_->DispatchInputEventToWindow(target.window, target.in_nonclient_area,
                                         *clone, nullptr);
@@ skipping 51 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus