chromeos: makes mus send keyevents to display root when nothing has focus

services/ui/ws/window_manager_state.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 <utility>
 
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 357 matching lines @@
       return;
     }
   }
 }
 
 void WindowManagerState::SetAllRootWindowsVisible(bool value) {
   for (auto& display_root_ptr : window_manager_display_roots_)
     display_root_ptr->root()->SetVisible(value);
 }
 
-ServerWindow* WindowManagerState::GetWindowManagerRoot(ServerWindow* window) {
+ServerWindow* WindowManagerState::GetWindowManagerRootForDisplayRoot(
+    ServerWindow* window) {
   for (auto& display_root_ptr : window_manager_display_roots_) {
     if (display_root_ptr->root()->parent() == window)
-      return display_root_ptr->root();
+      return display_root_ptr->GetClientVisibileRoot();
   }
   NOTREACHED();
   return nullptr;
 }
 
 void WindowManagerState::OnEventAck(mojom::WindowTree* tree,
                                     mojom::EventResult result) {
   DCHECK(in_flight_event_details_);
   std::unique_ptr<InFlightEventDetails> details =
       std::move(in_flight_event_details_);
@@ skipping 59 matching lines @@
   }
 }
 
 void WindowManagerState::DispatchInputEventToWindowImpl(
     ServerWindow* target,
     ClientSpecificId client_id,
     const ui::Event& event,
     base::WeakPtr<Accelerator> accelerator) {
   DCHECK(target);
   if (target->parent() == nullptr)
-    target = GetWindowManagerRoot(target);
+    target = GetWindowManagerRootForDisplayRoot(target);
 
   if (event.IsMousePointerEvent()) {
     DCHECK(event_dispatcher_.mouse_cursor_source_window());
     UpdateNativeCursorFromDispatcher();
   }
 
   WindowTree* tree = window_server()->GetTreeWithId(client_id);
   DCHECK(tree);
   ScheduleInputEventTimeout(tree, target, event, EventDispatchPhase::TARGET);
   in_flight_event_details_->post_target_accelerator = accelerator;
@@ skipping 85 matching lines @@
   window_tree_->OnAccelerator(accelerator_id, event, std::move(ack_callback));
 }
 
 void WindowManagerState::SetFocusedWindowFromEventDispatcher(
     ServerWindow* new_focused_window) {
   DCHECK(IsActive());
   window_server()->SetFocusedWindow(new_focused_window);
 }
 
 ServerWindow* WindowManagerState::GetFocusedWindowForEventDispatcher() {
-  return window_server()->GetFocusedWindow();
+  ServerWindow* focused_window = window_server()->GetFocusedWindow();
+  if (focused_window)
+    return focused_window;
+
+  // When none of the windows have focus return the window manager's root.
+  for (auto& display_root_ptr : window_manager_display_roots_) {
+    if (display_root_ptr->display()->GetId() == event_processing_display_id_)
+      return display_root_ptr->GetClientVisibileRoot();
+  }
+  if (!window_manager_display_roots_.empty())
+    return (*window_manager_display_roots_.begin())->GetClientVisibileRoot();
+  return nullptr;
 }
 
 void WindowManagerState::SetNativeCapture(ServerWindow* window) {
   DCHECK(window);
   DCHECK(IsActive());
   WindowManagerDisplayRoot* display_root =
       display_manager()->GetWindowManagerDisplayRoot(window);
   DCHECK(display_root);
   platform_display_with_capture_ = display_root->display()->platform_display();
   platform_display_with_capture_->SetCapture();
@@ skipping 97 matching lines @@
   if (!target_display_root) {
     DVLOG(1) << "Invalid event location " << location->ToString();
     target_display_root = window_manager_display_roots_.begin()->get();
   }
 
   // Translate the location to be relative to the display instead of relative
   // to the screen space.
   gfx::Point origin =
       target_display_root->display()->GetDisplay().bounds().origin();
   *location -= origin.OffsetFromOrigin();
-  return target_display_root->root();
+  return target_display_root->GetClientVisibileRoot();
 }
 
 void WindowManagerState::OnEventTargetNotFound(const ui::Event& event) {
   window_server()->SendToPointerWatchers(event, user_id(), nullptr, /* window */
                                          nullptr /* ignore_tree */,
                                          event_processing_display_id_);
   if (event.IsMousePointerEvent())
     UpdateNativeCursorFromDispatcher();
 }
 
 void WindowManagerState::OnWindowEmbeddedAppDisconnected(ServerWindow* window) {
   for (auto iter = orphaned_window_manager_display_roots_.begin();
        iter != orphaned_window_manager_display_roots_.end(); ++iter) {
     if ((*iter)->root() == window) {
       window->RemoveObserver(this);
       orphaned_window_manager_display_roots_.erase(iter);
       return;
     }
   }
   NOTREACHED();
 }
 
 }  // namespace ws
 }  // namespace ui