Dispatch key events to the currently focused window.

mojo/services/window_manager/view_targeter.cc

 // Copyright 2014 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 "mojo/services/window_manager/view_targeter.h"
 
+#include "mojo/services/window_manager/focus_controller.h"
 #include "mojo/services/window_manager/view_target.h"
 
 namespace mojo {
 
 ViewTargeter::ViewTargeter() {}
 
 ViewTargeter::~ViewTargeter() {}
 
 ui::EventTarget* ViewTargeter::FindTargetForEvent(ui::EventTarget* root,
                                                   ui::Event* event) {
-  // TODO(erg): We currently don't deal with key events very well here; we need
-  // to implement the logic in the aura version to fix key events here.
-  return EventTargeter::FindTargetForEvent(root, event);
+  ViewTarget* view = static_cast<ViewTarget*>(root);
+  ViewTarget* target =
+      event->IsKeyEvent()
+          ? FindTargetForKeyEvent(view, *static_cast<ui::KeyEvent*>(event))
+          : static_cast<ViewTarget*>(
+                EventTargeter::FindTargetForEvent(root, event));
+
+  // TODO(erg): The aura version of this method does a lot of work to handle
+  // dispatching to a target that isn't a child of |view|. For now, punt on
+  // this.
+  DCHECK_EQ(view->GetRoot(), target->GetRoot());
+
+  return target;
 }
 
 ui::EventTarget* ViewTargeter::FindTargetForLocatedEvent(
     ui::EventTarget* root,
     ui::LocatedEvent* event) {
   ViewTarget* view = static_cast<ViewTarget*>(root);
   if (!view->HasParent()) {
     ViewTarget* target = FindTargetInRootView(view, *event);
     if (target) {
       view->ConvertEventToTarget(target, event);
@@ skipping 21 matching lines @@
     ui::EventTarget* target,
     const ui::LocatedEvent& event) const {
   ViewTarget* view = static_cast<ViewTarget*>(target);
   gfx::Point point = event.location();
   const ViewTarget* parent = view->GetParent();
   if (parent)
     ViewTarget::ConvertPointToTarget(parent, view, &point);
   return gfx::Rect(view->GetBounds().size()).Contains(point);
 }
 
+ViewTarget* ViewTargeter::FindTargetForKeyEvent(ViewTarget* view_target,
+                                                const ui::KeyEvent& key) {
+  FocusController* focus_controller = GetFocusController(view_target->view());
+  View* focused_view = focus_controller->GetFocusedView();
+  if (focused_view)
+    return ViewTarget::TargetFromView(focused_view);
+
+  return view_target;
+}
+
 ViewTarget* ViewTargeter::FindTargetInRootView(ViewTarget* root_view,
                                                const ui::LocatedEvent& event) {
   // TODO(erg): This here is important because it resolves
   // mouse_pressed_handler() in the aura version. This is what makes sure
   // that a view gets both the mouse down and up.
 
   // TODO(erg): We redirect to a currently active capture window here. Add this
   // when we have capture working.
 
   // TODO(erg): There's a whole bunch of junk about handling touch events
   // here. Handle later.
 
   return nullptr;
 }
 
 }  // namespace mojo