Rework FocusManager as FocusClient.

ui/aura/root_window_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/event_client.h"
@@ skipping 84 matching lines @@
       delegate ? delegate :
       test::TestWindowDelegate::CreateSelfDestroyingDelegate());
   window->set_id(id);
   window->Init(ui::LAYER_TEXTURED);
   window->SetParent(parent);
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   window->Show();
   return window;
 }
 
+bool IsFocusedWindow(aura::Window* window) {
+  return client::GetFocusClient(window)->GetFocusedWindow() == window;
+}
+
 }  // namespace
 
 typedef test::AuraTestBase RootWindowTest;
 
 TEST_F(RootWindowTest, OnHostMouseEvent) {
   // Create two non-overlapping windows so we don't have to worry about which
   // is on top.
   scoped_ptr<NonClientDelegate> delegate1(new NonClientDelegate());
   scoped_ptr<NonClientDelegate> delegate2(new NonClientDelegate());
   const int kWindowWidth = 123;
@@ skipping 211 matching lines @@
                                                 client.GetNonLockWindow());
   w1->set_id(1);
   Window* w2 = test::CreateTestWindowWithBounds(gfx::Rect(30, 30, 20, 20),
                                                 client.GetNonLockWindow());
   w2->set_id(2);
   scoped_ptr<Window> w3(
       test::CreateTestWindowWithDelegate(&d, 3, gfx::Rect(30, 30, 20, 20),
                                          client.GetLockWindow()));
 
   w1->Focus();
-  EXPECT_TRUE(w1->GetFocusManager()->IsFocusedWindow(w1));
+  EXPECT_TRUE(IsFocusedWindow(w1));
 
   client.Lock();
 
   // Since we're locked, the attempt to focus w2 will be ignored.
   w2->Focus();
-  EXPECT_TRUE(w1->GetFocusManager()->IsFocusedWindow(w1));
-  EXPECT_FALSE(w1->GetFocusManager()->IsFocusedWindow(w2));
+  EXPECT_TRUE(IsFocusedWindow(w1));
+  EXPECT_FALSE(IsFocusedWindow(w2));
 
   {
     // Attempting to send a key event to w1 (not in the lock container) should
     // cause focus to be reset.
     test::EventGenerator generator(root_window());
     generator.PressKey(ui::VKEY_SPACE, 0);
-    EXPECT_EQ(NULL, w1->GetFocusManager()->GetFocusedWindow());
+    EXPECT_EQ(NULL, client::GetFocusClient(w1)->GetFocusedWindow());
   }
 
   {
     // Events sent to a window not in the lock container will not be processed.
     // i.e. never sent to the non-lock container's event filter.
     test::EventGenerator generator(root_window(), w1);
     generator.PressLeftButton();
     EXPECT_EQ(0, nonlock_ef->num_mouse_events());
 
     // Events sent to a window in the lock container will be processed.
@@ skipping 334 matching lines @@
 TEST_F(RootWindowTest, DeleteWindowDuringDispatch) {
   // Verifies that we can delete a window during each phase of event handling.
   // Deleting the window should not cause a crash, only prevent further
   // processing from occurring.
   scoped_ptr<Window> w1(CreateWindow(1, root_window(), NULL));
   DeletingWindowDelegate d11;
   Window* w11 = CreateWindow(11, w1.get(), &d11);
   WindowTracker tracker;
   DeletingEventFilter* w1_filter = new DeletingEventFilter;
   w1->SetEventFilter(w1_filter);
-  w1->GetFocusManager()->SetFocusedWindow(w11, NULL);
+  client::GetFocusClient(w1.get())->FocusWindow(w11, NULL);
 
   test::EventGenerator generator(root_window(), w11);
 
   // First up, no one deletes anything.
   tracker.Add(w11);
   d11.Reset(w11, false);
 
   generator.PressLeftButton();
   EXPECT_TRUE(tracker.Contains(w11));
   EXPECT_TRUE(d11.got_event());
@@ skipping 48 matching lines @@
 TEST_F(RootWindowTest, GestureRecognizerResetsTargetWhenParentHides) {
   scoped_ptr<Window> w1(CreateWindow(1, root_window(), NULL));
   DetachesParentOnTapDelegate delegate;
   scoped_ptr<Window> parent(CreateWindow(22, w1.get(), NULL));
   Window* child = CreateWindow(11, parent.get(), &delegate);
   test::EventGenerator generator(root_window(), child);
   generator.GestureTapAt(gfx::Point(40, 40));
 }
 
 }  // namespace aura