Rework FocusManager as FocusClient.

ash/wm/activation_controller.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 "ash/wm/activation_controller.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/activation_controller_delegate.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_modality_controller.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/client/aura_constants.h"
+#include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 
 namespace ash {
 namespace internal {
 namespace {
 
@@ skipping 106 matching lines @@
     window = window->parent();
   return window;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, public:
 
 ActivationController::ActivationController(
-    aura::FocusManager* focus_manager,
+    aura::client::FocusClient* focus_client,
     ActivationControllerDelegate* delegate)
-    : focus_manager_(focus_manager),
+    : focus_client_(focus_client),
       updating_activation_(false),
       active_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(observer_manager_(this)),
       delegate_(delegate) {
   aura::Env::GetInstance()->AddObserver(this);
-  focus_manager_->AddObserver(this);
+  focus_client_->AddObserver(this);
 }
 
 ActivationController::~ActivationController() {
   aura::Env::GetInstance()->RemoveObserver(this);
-  focus_manager_->RemoveObserver(this);
+  focus_client_->RemoveObserver(this);
 }
 
 // static
 aura::Window* ActivationController::GetActivatableWindow(
     aura::Window* window,
     const ui::Event* event) {
   aura::Window* parent = window->parent();
   aura::Window* child = window;
   while (parent) {
     if (CanActivateWindowWithEvent(child, event, CURRENT_VISIBILITY))
@@ skipping 142 matching lines @@
   if (window && !CanActivateWindowWithEvent(window, event, CURRENT_VISIBILITY))
     return;
 
   if (active_window_ == window)
     return;
 
   aura::Window* old_active = active_window_;
   active_window_ = window;
 
   if (window &&
-      !window->Contains(window->GetFocusManager()->GetFocusedWindow())) {
-    window->GetFocusManager()->SetFocusedWindow(window, event);
+      !window->Contains(aura::client::GetFocusClient(window)->
+          GetFocusedWindow())) {
+    aura::client::GetFocusClient(window)->FocusWindow(window, event);
   }
 
   FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver,
                     observers_,
                     OnWindowActivated(window, old_active));
 
   // Invoke OnLostActive after we've changed the active window. That way if
   // the delegate queries for active state it doesn't think the window is
   // still active.
   if (old_active && aura::client::GetActivationDelegate(old_active))
@@ skipping 71 matching lines @@
         CanActivateWindowWithEvent(*i, NULL, CURRENT_VISIBILITY) &&
         !wm::IsWindowMinimized(*i))
       return *i;
   }
   return NULL;
 }
 
 void ActivationController::FocusWindowWithEvent(const ui::Event* event) {
   aura::Window* window = static_cast<aura::Window*>(event->target());
   if (GetActiveWindow() != window) {
-    window->GetFocusManager()->SetFocusedWindow(
+    aura::client::GetFocusClient(window)->FocusWindow(
         FindFocusableWindowFor(window), event);
   }
 }
 
 }  // namespace internal
 }  // namespace ash