Dispatch key events to the currently focused window.

mojo/services/window_manager/window_manager_app.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/window_manager_app.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
@@ skipping 105 matching lines @@
   focus_controller_->ActivateView(view);
 }
 
 bool WindowManagerApp::IsReady() const {
   return view_manager_ && root_;
 }
 
 void WindowManagerApp::InitFocus(scoped_ptr<mojo::FocusRules> rules) {
   focus_controller_.reset(new mojo::FocusController(rules.Pass()));
   focus_controller_->AddObserver(this);
+
+  if (root_)
+    ViewTarget::TargetFromView(root_)
+        ->set_focus_controller(focus_controller_.get());
 }
 
 void WindowManagerApp::Embed(
     const String& url,
     InterfaceRequest<ServiceProvider> service_provider) {
   if (view_manager_) {
     window_manager_delegate_->Embed(url, service_provider.Pass());
     return;
   }
   scoped_ptr<PendingEmbed> pending_embed(new PendingEmbed);
@@ skipping 134 matching lines @@
 // WindowManagerApp, private:
 
 void WindowManagerApp::RegisterSubtree(View* view) {
   view->AddObserver(this);
   DCHECK(registered_view_id_set_.find(view->id()) ==
          registered_view_id_set_.end());
   // All events pass through the root during dispatch, so we only need a handler
   // installed there.
   if (view == root_) {
     ViewTarget* target = ViewTarget::TargetFromView(view);
+    if (focus_controller_)

[sky, 2014/11/18 22:36:38]

Is it really possible to get here with no focuscontroller?

[Elliot Glaysher, 2014/11/18 23:52:30]

Not only is it possible, it is the default.

RegisterSubtree is called from OnEmbed() which is part of the delegate
interface. However, the thing that calls InitFocus() is also called from a
different OnEmbed() that observes the same View hierarchy.

In short, this was here for safety in case the observers are added in a
different order, but I'll drop it for now as I guess that's really unlikely.

+      target->set_focus_controller(focus_controller_.get());
     target->SetEventTargeter(scoped_ptr<ViewTargeter>(new ViewTargeter()));
     target->AddPreTargetHandler(this);
     view_event_dispatcher_->SetRootViewTarget(target);
   }
+
   registered_view_id_set_.insert(view->id());
   View::Children::const_iterator it = view->children().begin();
   for (; it != view->children().end(); ++it)
     RegisterSubtree(*it);
 }
 
 void WindowManagerApp::UnregisterSubtree(View* view) {
   for (View* child : view->children())
     UnregisterSubtree(child);
   Unregister(view);
@@ skipping 40 matching lines @@
   view_manager_app->ConnectToService(&window_manager_client_);
 }
 
 void WindowManagerApp::Create(ApplicationConnection* connection,
                               InterfaceRequest<WindowManagerInternal> request) {
   WindowManagerInternalImpl* impl = new WindowManagerInternalImpl(this);
   BindToRequest(impl, &request);
 }
 
 }  // namespace mojo