Rework FocusManager as FocusClient.

ui/aura/root_window.cc

 // Copyright (c) 2012 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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
+#include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/events/event.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/view_prop.h"
@@ skipping 63 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(host_(CreateHost(this, params))),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(event_factory_(this)),
       mouse_button_flags_(0),
       touch_ids_down_(0),
       last_cursor_(ui::kCursorNull),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       mouse_event_dispatch_target_(NULL),
       event_dispatch_target_(NULL),
-      focus_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       defer_draw_scheduling_(false),
       mouse_move_hold_count_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(held_mouse_event_factory_(this)) {
   SetName("RootWindow");
 
@@ skipping 404 matching lines @@
 // RootWindow, overridden from aura::Window:
 
 bool RootWindow::CanFocus() const {
   return IsVisible();
 }
 
 bool RootWindow::CanReceiveEvents() const {
   return IsVisible();
 }
 
-FocusManager* RootWindow::GetFocusManager() {
-  return focus_manager_;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, overridden from aura::client::CaptureDelegate:
 
 void RootWindow::UpdateCapture(Window* old_capture,
                                Window* new_capture) {
   if (old_capture && old_capture->GetRootWindow() == this &&
       old_capture->delegate()) {
     // Send a capture changed event with bogus location data.
     ui::MouseEvent event(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(),
                          gfx::Point(), 0);
@@ skipping 140 matching lines @@
 }
 
 void RootWindow::OnWindowHidden(Window* invisible,
                                 WindowHiddenReason reason,
                                 RootWindow* new_root) {
     // Update the focused window state if the invisible window contains
   // focused_window. See the comment below, which also applies for focus with
   // the exception for the case where the focus managers change (otherwise a
   // focus manager might dereference a deleted root window).
   if (reason != WINDOW_MOVING ||
-      (new_root->GetFocusManager() != focus_manager_)) {
-    Window* focused_window = focus_manager_->GetFocusedWindow();
+      (client::GetFocusClient(new_root) != client::GetFocusClient(this))) {
+    Window* focused_window = client::GetFocusClient(this)->GetFocusedWindow();
     if (invisible->Contains(focused_window)) {
       Window* focus_to = invisible->transient_parent();
       if (focus_to) {
         // Has to be removed from the transient parent before focusing,
         // otherwise |window| will be focused again.
         if (reason == WINDOW_DESTROYED)
           focus_to->RemoveTransientChild(invisible);
       } else {
         // If the invisible view has no visible transient window, focus to the
         // topmost visible parent window.
         focus_to = invisible->parent();
       }
       if (focus_to &&
           (!focus_to->IsVisible() ||
            !focus_to->CanFocus() ||
            (client::GetActivationClient(this) &&
             !client::GetActivationClient(this)->OnWillFocusWindow(focus_to,
                                                                   NULL)))) {
         focus_to = NULL;
       }
-      GetFocusManager()->SetFocusedWindow(focus_to, NULL);
+      client::GetFocusClient(this)->FocusWindow(focus_to, NULL);
     }
   }
 
   // Do not clear the capture, and the dispatch targets if the window is moving
   // across root windows, because the target itself is actually still visible
   // and clearing them stops further event processing, which can cause
   // unexpected behaviors. See crbug.com/157583
   if (reason != WINDOW_MOVING) {
     Window* capture_window = aura::client::GetCaptureWindow(this);
     // If the ancestor of the capture window is hidden,
@@ skipping 58 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, RootWindowHostDelegate implementation:
 
 bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
   DispatchHeldMouseMove();
   if (event->key_code() == ui::VKEY_UNKNOWN)
     return false;
   client::EventClient* client = client::GetEventClient(GetRootWindow());
-  Window* focused_window = focus_manager_->GetFocusedWindow();
+  Window* focused_window = client::GetFocusClient(this)->GetFocusedWindow();
   if (client && !client->CanProcessEventsWithinSubtree(focused_window)) {
-    GetFocusManager()->SetFocusedWindow(NULL, NULL);
+    client::GetFocusClient(this)->FocusWindow(NULL, NULL);
     return false;
   }
   return ProcessKeyEvent(focused_window, event);
 }
 
 bool RootWindow::OnHostMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_DRAGGED ||
       (event->flags() & ui::EF_IS_SYNTHESIZED)) {
     if (mouse_move_hold_count_) {
       Window* null_window = static_cast<Window*>(NULL);
@@ skipping 236 matching lines @@
   ui::MouseEvent event(ui::ET_MOUSE_MOVED,
                        orig_mouse_location,
                        orig_mouse_location,
                        ui::EF_IS_SYNTHESIZED);
   event.set_system_location(Env::GetInstance()->last_mouse_location());
   OnHostMouseEvent(&event);
 #endif
 }
 
 }  // namespace aura