Rename Desktop->RootWindow.

ui/aura/window_unittest.cc

 // Copyright (c) 2011 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/window.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/stacking_client.h"
-#include "ui/aura/desktop.h"
-#include "ui/aura/desktop_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/focus_manager.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/root_window_observer.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/layer.h"
@@ skipping 169 matching lines @@
   scoped_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
   scoped_ptr<Window> w12(
       CreateTestWindow(SK_ColorMAGENTA, 12, gfx::Rect(10, 420, 25, 25),
                        w1.get()));
   scoped_ptr<Window> w121(
       CreateTestWindow(SK_ColorYELLOW, 121, gfx::Rect(5, 5, 5, 5), w12.get()));
   scoped_ptr<Window> w13(
       CreateTestWindow(SK_ColorGRAY, 13, gfx::Rect(5, 470, 50, 50), w1.get()));
 
-  Window* root = Desktop::GetInstance();
+  Window* root = RootWindow::GetInstance();
   w1->parent()->SetBounds(gfx::Rect(500, 500));
   EXPECT_EQ(NULL, root->GetEventHandlerForPoint(gfx::Point(5, 5)));
   EXPECT_EQ(w1.get(), root->GetEventHandlerForPoint(gfx::Point(11, 11)));
   EXPECT_EQ(w11.get(), root->GetEventHandlerForPoint(gfx::Point(16, 16)));
   EXPECT_EQ(w111.get(), root->GetEventHandlerForPoint(gfx::Point(21, 21)));
   EXPECT_EQ(w1111.get(), root->GetEventHandlerForPoint(gfx::Point(26, 26)));
   EXPECT_EQ(w12.get(), root->GetEventHandlerForPoint(gfx::Point(21, 431)));
   EXPECT_EQ(w121.get(), root->GetEventHandlerForPoint(gfx::Point(26, 436)));
   EXPECT_EQ(w13.get(), root->GetEventHandlerForPoint(gfx::Point(26, 481)));
 }
 
 TEST_F(WindowTest, GetTopWindowContainingPoint) {
-  Window* root = Desktop::GetInstance();
+  Window* root = RootWindow::GetInstance();
   root->SetBounds(gfx::Rect(0, 0, 300, 300));
 
   scoped_ptr<Window> w1(
       CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 100, 100), NULL));
   scoped_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(0, 0, 120, 120), w1.get()));
 
   scoped_ptr<Window> w2(
       CreateTestWindow(SK_ColorRED, 2, gfx::Rect(5, 5, 55, 55), NULL));
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(110, 110)));
   EXPECT_EQ(w31.get(), root->GetTopWindowContainingPoint(gfx::Point(200, 200)));
   EXPECT_EQ(w31.get(), root->GetTopWindowContainingPoint(gfx::Point(220, 220)));
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(260, 260)));
 }
 
 TEST_F(WindowTest, GetToplevelWindow) {
   const gfx::Rect kBounds(0, 0, 10, 10);
   TestWindowDelegate delegate;
 
-  Window* root = aura::Desktop::GetInstance();
+  Window* root = aura::RootWindow::GetInstance();
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, root));
   scoped_ptr<Window> w11(
       CreateTestWindowWithDelegate(&delegate, 11, kBounds, w1.get()));
   scoped_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
   scoped_ptr<Window> w1111(
       CreateTestWindowWithDelegate(&delegate, 1111, kBounds, w111.get()));
 
   EXPECT_TRUE(root->GetToplevelWindow() == NULL);
   EXPECT_TRUE(w1->GetToplevelWindow() == NULL);
   EXPECT_EQ(w11.get(), w11->GetToplevelWindow());
@@ skipping 98 matching lines @@
   EXPECT_EQ(&child1, parent.children()[1]);
   EXPECT_EQ(&child3, parent.children()[2]);
   ASSERT_EQ(3u, parent.layer()->children().size());
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child3.layer(), parent.layer()->children()[2]);
 }
 
 // Various destruction assertions.
 TEST_F(WindowTest, CaptureTests) {
-  aura::Desktop* desktop = aura::Desktop::GetInstance();
+  aura::RootWindow* root_window = aura::RootWindow::GetInstance();
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
   EXPECT_EQ(0, delegate.capture_lost_count());
   EventGenerator generator(gfx::Point(50, 50));
   generator.PressLeftButton();
   EXPECT_EQ(1, delegate.mouse_event_count());
   generator.ReleaseLeftButton();
 
   EXPECT_EQ(2, delegate.mouse_event_count());
   delegate.set_mouse_event_count(0);
 
   TouchEvent touchev(ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), 0);
-  desktop->DispatchTouchEvent(&touchev);
+  root_window->DispatchTouchEvent(&touchev);
   EXPECT_EQ(1, delegate.touch_event_count());
   delegate.set_touch_event_count(0);
 
   window->ReleaseCapture();
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(1, delegate.capture_lost_count());
 
   generator.PressLeftButton();
   EXPECT_EQ(0, delegate.mouse_event_count());
 
-  desktop->DispatchTouchEvent(&touchev);
+  root_window->DispatchTouchEvent(&touchev);
   EXPECT_EQ(0, delegate.touch_event_count());
 
   // Removing the capture window from parent should reset the capture window
-  // in the desktop.
+  // in the root window.
   window->SetCapture();
-  EXPECT_EQ(window.get(), desktop->capture_window());
+  EXPECT_EQ(window.get(), root_window->capture_window());
   window->parent()->RemoveChild(window.get());
   EXPECT_FALSE(window->HasCapture());
-  EXPECT_EQ(NULL, desktop->capture_window());
+  EXPECT_EQ(NULL, root_window->capture_window());
 }
 
 // Verifies capture is reset when a window is destroyed.
 TEST_F(WindowTest, ReleaseCaptureOnDestroy) {
-  Desktop* desktop = Desktop::GetInstance();
+  RootWindow* root_window = RootWindow::GetInstance();
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
 
   // Destroy the window.
   window.reset();
 
-  // Make sure the desktop doesn't reference the window anymore.
-  EXPECT_EQ(NULL, desktop->mouse_pressed_handler());
-  EXPECT_EQ(NULL, desktop->capture_window());
+  // Make sure the root window doesn't reference the window anymore.
+  EXPECT_EQ(NULL, root_window->mouse_pressed_handler());
+  EXPECT_EQ(NULL, root_window->capture_window());
 }
 
 TEST_F(WindowTest, GetScreenBounds) {
   scoped_ptr<Window> viewport(CreateTestWindowWithBounds(
       gfx::Rect(0, 0, 300, 300), NULL));
   scoped_ptr<Window> child(CreateTestWindowWithBounds(
       gfx::Rect(0, 0, 100, 100), viewport.get()));
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetScreenBounds().ToString());
 
@@ skipping 32 matching lines @@
   bool entered_;
   bool exited_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseEnterExitWindowDelegate);
 };
 
 
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window.
 TEST_F(WindowTest, MouseEnterExit) {
-  Desktop* desktop = Desktop::GetInstance();
+  RootWindow* root_window = RootWindow::GetInstance();
 
   MouseEnterExitWindowDelegate d1;
   scoped_ptr<Window> w1(
       CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
   MouseEnterExitWindowDelegate d2;
   scoped_ptr<Window> w2(
       CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50), NULL));
 
   gfx::Point move_point = w1->bounds().CenterPoint();
-  Window::ConvertPointToWindow(w1->parent(), desktop, &move_point);
+  Window::ConvertPointToWindow(w1->parent(), root_window, &move_point);
   MouseEvent mouseev1(ui::ET_MOUSE_MOVED, move_point, 0);
-  desktop->DispatchMouseEvent(&mouseev1);
+  root_window->DispatchMouseEvent(&mouseev1);
 
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   move_point = w2->bounds().CenterPoint();
-  Window::ConvertPointToWindow(w2->parent(), desktop, &move_point);
+  Window::ConvertPointToWindow(w2->parent(), root_window, &move_point);
   MouseEvent mouseev2(ui::ET_MOUSE_MOVED, move_point, 0);
-  desktop->DispatchMouseEvent(&mouseev2);
+  root_window->DispatchMouseEvent(&mouseev2);
 
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 namespace {
 
 class ActiveWindowDelegate : public TestWindowDelegate {
@@ skipping 22 matching lines @@
   int hit_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ActiveWindowDelegate);
 };
 
 }  // namespace
 
 // Verifies that when WindowDelegate::OnLostActive is invoked the window is not
 // active.
 TEST_F(WindowTest, NotActiveInLostActive) {
-  Desktop* desktop = Desktop::GetInstance();
+  RootWindow* root_window = RootWindow::GetInstance();
 
   ActiveWindowDelegate d1;
   scoped_ptr<Window> w1(
       CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
   d1.set_window(w1.get());
   scoped_ptr<Window> w2(
       CreateTestWindowWithDelegate(NULL, 1, gfx::Rect(10, 10, 50, 50), NULL));
 
   // Activate w1.
-  desktop->SetActiveWindow(w1.get(), NULL);
-  EXPECT_EQ(w1.get(), desktop->active_window());
+  root_window->SetActiveWindow(w1.get(), NULL);
+  EXPECT_EQ(w1.get(), root_window->active_window());
 
   // Should not have gotten a OnLostActive yet.
   EXPECT_EQ(0, d1.hit_count());
 
   // SetActiveWindow(NULL) should not change the active window.
-  desktop->SetActiveWindow(NULL, NULL);
-  EXPECT_TRUE(desktop->active_window() == w1.get());
+  root_window->SetActiveWindow(NULL, NULL);
+  EXPECT_TRUE(root_window->active_window() == w1.get());
 
   // Now activate another window.
-  desktop->SetActiveWindow(w2.get(), NULL);
+  root_window->SetActiveWindow(w2.get(), NULL);
 
   // Should have gotten OnLostActive and w1 should not have been active at that
   // time.
   EXPECT_EQ(1, d1.hit_count());
   EXPECT_FALSE(d1.was_active());
 }
 
 // Creates a window with a delegate (w111) that can handle events at a lower
 // z-index than a window without a delegate (w12). w12 is sized to fill the
 // entire bounds of the container. This test verifies that
@@ skipping 185 matching lines @@
   EXPECT_FALSE(w2->IsActive());
   EXPECT_EQ(w1.get(), parent->children()[1]);
 
   // Deactivate w1 and make sure w2 becomes active and frontmost.
   w1->Deactivate();
   EXPECT_FALSE(w1->IsActive());
   EXPECT_TRUE(w2->IsActive());
   EXPECT_EQ(w2.get(), parent->children()[1]);
 }
 
-// Tests transformation on the desktop.
+// Tests transformation on the root window.
 TEST_F(WindowTest, Transform) {
-  Desktop* desktop = Desktop::GetInstance();
-  gfx::Size size = desktop->GetHostSize();
+  RootWindow* root_window = RootWindow::GetInstance();
+  gfx::Size size = root_window->GetHostSize();
   EXPECT_EQ(gfx::Rect(size),
             gfx::Screen::GetMonitorAreaNearestPoint(gfx::Point()));
 
   // Rotate it clock-wise 90 degrees.
   ui::Transform transform;
   transform.SetRotate(90.0f);
   transform.ConcatTranslate(size.width(), 0);
-  desktop->SetTransform(transform);
+  root_window->SetTransform(transform);
 
   // The size should be the transformed size.
   gfx::Size transformed_size(size.height(), size.width());
-  EXPECT_EQ(transformed_size.ToString(), desktop->GetHostSize().ToString());
+  EXPECT_EQ(transformed_size.ToString(), root_window->GetHostSize().ToString());
   EXPECT_EQ(gfx::Rect(transformed_size).ToString(),
-            desktop->bounds().ToString());
+            root_window->bounds().ToString());
   EXPECT_EQ(gfx::Rect(transformed_size).ToString(),
             gfx::Screen::GetMonitorAreaNearestPoint(gfx::Point()).ToString());
 }
 
 // Various assertions for transient children.
 TEST_F(WindowTest, TransientChildren) {
   scoped_ptr<Window> parent(CreateTestWindowWithId(0, NULL));
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
   scoped_ptr<Window> w3(CreateTestWindowWithId(3, parent.get()));
   Window* w2 = CreateTestWindowWithId(2, parent.get());
@@ skipping 277 matching lines @@
   EXPECT_EQ(2, w1->GetIntProperty(key));
   EXPECT_EQ(reinterpret_cast<void*>(2), w1->GetProperty(key));
   EXPECT_EQ("name=test old=1 new=2", PropertyChangeInfoAndClear());
   w1->SetProperty(key, NULL);
   EXPECT_EQ("name=test old=2 new=0", PropertyChangeInfoAndClear());
 
   // Sanity check to see if |PropertyChangeInfoAndClear| really clears.
   EXPECT_EQ("name= old=0 new=0", PropertyChangeInfoAndClear());
 }
 
-class DesktopObserverTest : public WindowTest,
-                            public DesktopObserver {
+class RootWindowObserverTest : public WindowTest,
+                               public RootWindowObserver {
  public:
-  DesktopObserverTest() : active_(NULL) {
+  RootWindowObserverTest() : active_(NULL) {
   }
 
-  virtual ~DesktopObserverTest() {}
+  virtual ~RootWindowObserverTest() {}
 
   Window* active() const { return active_; }
 
   void Reset() {
     active_ = NULL;
   }
 
  private:
   virtual void SetUp() OVERRIDE {
     WindowTest::SetUp();
-    Desktop::GetInstance()->AddObserver(this);
+    RootWindow::GetInstance()->AddObserver(this);
   }
 
   virtual void TearDown() OVERRIDE {
-    Desktop::GetInstance()->RemoveObserver(this);
+    RootWindow::GetInstance()->RemoveObserver(this);
     WindowTest::TearDown();
   }
 
   virtual void OnActiveWindowChanged(Window* active) OVERRIDE {
     active_ = active;
   }
 
   Window* active_;
 
-  DISALLOW_COPY_AND_ASSIGN(DesktopObserverTest);
+  DISALLOW_COPY_AND_ASSIGN(RootWindowObserverTest);
 };
 
-TEST_F(DesktopObserverTest, WindowActivationObserve) {
+TEST_F(RootWindowObserverTest, WindowActivationObserve) {
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
   scoped_ptr<Window> w2(CreateTestWindowWithId(2, NULL));
   scoped_ptr<Window> w3(CreateTestWindowWithId(3, w1.get()));
 
   EXPECT_EQ(NULL, active());
 
   w2->Activate();
   EXPECT_EQ(w2.get(), active());
 
   w3->Activate();
   EXPECT_EQ(w2.get(), active());
 
   w1->Activate();
   EXPECT_EQ(w1.get(), active());
 }
 
 }  // namespace test
 }  // namespace aura