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 GetWindowManagerRoot(display_root_ptr.get());
   }
   NOTREACHED();
   return nullptr;
 }
 
+ServerWindow* WindowManagerState::GetWindowManagerRoot(
+    WindowManagerDisplayRoot* display_root) {
+  if (window_tree_->automatically_create_display_roots())
+    return display_root->root();
+  DCHECK_EQ(1u, display_root->root()->children().size());
+  return display_root->root()->children()[0];

[sadrul, 2017/05/08 15:24:19]

Maybe there should be a WindowManagerDisplayRoot::Get[Client]VisibleRoot() or
something like that? Because most code will probably end up using
WindowManagerDisplayRoot::root(), unaware that there may be a different root to
consider.

[sky, 2017/05/08 15:53:00]

Good idea. Done.

+}
+
 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_);
 
   if (result == mojom::EventResult::UNHANDLED &&
       details->post_target_accelerator) {
     OnAccelerator(details->post_target_accelerator->id(), *details->event,
                   AcceleratorPhase::POST);
@@ skipping 54 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 GetWindowManagerRoot(display_root_ptr.get());
+    }
+  }
+  if (!window_manager_display_roots_.empty())
+    return GetWindowManagerRoot(window_manager_display_roots_.begin()->get());
+  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 122 matching lines @@
       window->RemoveObserver(this);
       orphaned_window_manager_display_roots_.erase(iter);
       return;
     }
   }
   NOTREACHED();
 }
 
 }  // namespace ws
 }  // namespace ui