Desktop aura: Break aura::Window::SetParent in two.

ui/aura/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/window.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 42 matching lines @@
     ui::GestureConfiguration::
         set_max_separation_for_gesture_touches_in_pixels(0);
   }
 
   virtual void TearDown() OVERRIDE {
     AuraTestBase::TearDown();
     ui::GestureConfiguration::
         set_max_separation_for_gesture_touches_in_pixels(max_separation_);
   }
 
+  // Adds |window| to |root_window_|, through the StackingClient.
+  void AddToRootWindow(aura::Window* window) {

[sky, 2012/11/21 23:35:59]

Again, I think this should match the method name you're calling.

+    window->SetDefaultParentByTargetRoot(root_window(), gfx::Rect());
+  }
+
+
  private:
   int max_separation_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTest);
 };
 
 namespace {
 
 // Used for verifying destruction methods are invoked.
 class DestroyTrackingDelegateImpl : public TestWindowDelegate {
@@ skipping 173 matching lines @@
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SelfEventHandlingWindowDelegate);
 };
 
 }  // namespace
 
 TEST_F(WindowTest, GetChildById) {
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> w11(CreateTestWindowWithId(11, w1.get()));
   scoped_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
   scoped_ptr<Window> w12(CreateTestWindowWithId(12, w1.get()));
 
   EXPECT_EQ(NULL, w1->GetChildById(57));
   EXPECT_EQ(w12.get(), w1->GetChildById(12));
   EXPECT_EQ(w111.get(), w1->GetChildById(111));
 }
 
 // Make sure that Window::Contains correctly handles children, grandchildren,
 // and not containing NULL or parents.
 TEST_F(WindowTest, Contains) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
 
-  child1.SetParent(&parent);
-  child2.SetParent(&child1);
+  parent.AddChild(&child1);
+  child1.AddChild(&child2);
 
   EXPECT_TRUE(parent.Contains(&parent));
   EXPECT_TRUE(parent.Contains(&child1));
   EXPECT_TRUE(parent.Contains(&child2));
 
   EXPECT_FALSE(parent.Contains(NULL));
   EXPECT_FALSE(child1.Contains(&parent));
   EXPECT_FALSE(child2.Contains(&child1));
 }
 
 TEST_F(WindowTest, ContainsPointInRoot) {
   scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5),
+                       root_window()));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(9, 9)));
   EXPECT_TRUE(w->ContainsPointInRoot(gfx::Point(10, 10)));
   EXPECT_TRUE(w->ContainsPointInRoot(gfx::Point(14, 14)));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(15, 15)));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(20, 20)));
 }
 
 TEST_F(WindowTest, ContainsPoint) {
   scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5),
+                       root_window()));
   EXPECT_TRUE(w->ContainsPoint(gfx::Point(0, 0)));
   EXPECT_TRUE(w->ContainsPoint(gfx::Point(4, 4)));
   EXPECT_FALSE(w->ContainsPoint(gfx::Point(5, 5)));
   EXPECT_FALSE(w->ContainsPoint(gfx::Point(10, 10)));
 }
 
 TEST_F(WindowTest, ConvertPointToWindow) {
   // Window::ConvertPointToWindow is mostly identical to
   // Layer::ConvertPointToLayer, except NULL values for |source| are permitted,
   // in which case the function just returns.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   gfx::Point reference_point(100, 100);
   gfx::Point test_point = reference_point;
   Window::ConvertPointToTarget(NULL, w1.get(), &test_point);
   EXPECT_EQ(reference_point, test_point);
 }
 
 TEST_F(WindowTest, MoveCursorTo) {
   scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
+                       root_window()));
   scoped_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
   scoped_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
   scoped_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
 
   RootWindow* root = root_window();
   root->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("10,10",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("20,20",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
   w11->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("25,25",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
   w111->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("30,30",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
   w1111->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("35,35",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
 }
 
 TEST_F(WindowTest, ContainsMouse) {
   scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
+                       root_window()));
   w->Show();
   Window::TestApi w_test_api(w.get());
   RootWindow* root = root_window();
   root->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_TRUE(w_test_api.ContainsMouse());
   root->MoveCursorTo(gfx::Point(9, 10));
   EXPECT_FALSE(w_test_api.ContainsMouse());
 }
 
 // Test Window::ConvertPointToWindow() with transform to root_window.
 TEST_F(WindowTest, MoveCursorToWithTransformRootWindow) {
   RootWindow* root = root_window();
   gfx::Transform transform;
   transform.ConcatScale(2, 5);
   transform.ConcatRotate(90.0f);
   transform.ConcatTranslate(100, 100);
   root->SetTransform(transform);
   root->MoveCursorTo(gfx::Point(10, 10));
 #if !defined(OS_WIN)
   // TODO(yoshiki): fix this to build on Windows. See crbug.com/133413.OD
   EXPECT_EQ("50,120", root->QueryMouseLocationForTest().ToString());
 #endif
   EXPECT_EQ("10,10",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
 }
 
 // Tests Window::ConvertPointToWindow() with transform to non-root windows.
 TEST_F(WindowTest, MoveCursorToWithTransformWindow) {
   scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
+                       root_window()));
 
   gfx::Transform transform1;
   transform1.ConcatScale(2, 2);
   w1->SetTransform(transform1);
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("30,30",
       gfx::Screen::GetScreenFor(w1.get())->GetCursorScreenPoint().ToString());
 
   gfx::Transform transform2;
   transform2.ConcatTranslate(-10, 20);
@@ skipping 16 matching lines @@
   w1->SetTransform(transform4);
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("60,130",
       gfx::Screen::GetScreenFor(w1.get())->GetCursorScreenPoint().ToString());
 }
 
 // Test Window::ConvertPointToWindow() with complex transforms to both root and
 // non-root windows.
 TEST_F(WindowTest, MoveCursorToWithComplexTransform) {
   scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
+                       root_window()));
   scoped_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
   scoped_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
   scoped_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
 
   RootWindow* root = root_window();
 
   // The root window expects transforms that produce integer rects.
@@ skipping 23 matching lines @@
   EXPECT_EQ("20,53",
       gfx::Screen::GetScreenFor(root)->GetCursorScreenPoint().ToString());
 }
 
 TEST_F(WindowTest, HitTest) {
   Window w1(new ColorTestWindowDelegate(SK_ColorWHITE));
   w1.set_id(1);
   w1.Init(ui::LAYER_TEXTURED);
   w1.SetBounds(gfx::Rect(10, 20, 50, 60));
   w1.Show();
-  w1.SetParent(NULL);
+  AddToRootWindow(&w1);
 
   // Points are in the Window's coordinates.
   EXPECT_TRUE(w1.HitTest(gfx::Point(1, 1)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(-1, -1)));
 
   // We can expand the bounds slightly to track events outside our border.
   w1.SetHitTestBoundsOverrideOuter(gfx::Insets(-1, -1, -1, -1), 5);
   EXPECT_TRUE(w1.HitTest(gfx::Point(-1, -1)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(-2, -2)));
 
@@ skipping 10 matching lines @@
 
   // TODO(beng): clip Window to parent.
 }
 
 TEST_F(WindowTest, HitTestMask) {
   MaskedWindowDelegate d1(gfx::Rect(5, 6, 20, 30));
   Window w1(&d1);
   w1.Init(ui::LAYER_NOT_DRAWN);
   w1.SetBounds(gfx::Rect(10, 20, 50, 60));
   w1.Show();
-  w1.SetParent(NULL);
+  AddToRootWindow(&w1);
 
   // Points inside the mask.
   EXPECT_TRUE(w1.HitTest(gfx::Point(5, 6)));  // top-left
   EXPECT_TRUE(w1.HitTest(gfx::Point(15, 21)));  // center
   EXPECT_TRUE(w1.HitTest(gfx::Point(24, 35)));  // bottom-right
 
   // Points outside the mask.
   EXPECT_FALSE(w1.HitTest(gfx::Point(0, 0)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(60, 80)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(4, 6)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(5, 5)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(25, 36)));
 }
 
 TEST_F(WindowTest, GetEventHandlerForPoint) {
   scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
+                       root_window()));
   scoped_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
   scoped_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
   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(
@@ skipping 10 matching lines @@
   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, GetEventHandlerForPointWithOverride) {
   // If our child is flush to our top-left corner he gets events just inside the
   // window edges.
   scoped_ptr<Window> parent(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 20, 400, 500), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 20, 400, 500),
+                       root_window()));
   scoped_ptr<Window> child(
       CreateTestWindow(SK_ColorRED, 2, gfx::Rect(0, 0, 60, 70), parent.get()));
   EXPECT_EQ(child.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(child.get(), parent->GetEventHandlerForPoint(gfx::Point(1, 1)));
 
   // We can override the hit test bounds of the parent to make the parent grab
   // events along that edge.
   parent->set_hit_test_bounds_override_inner(gfx::Insets(1, 1, 1, 1));
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(child.get(),  parent->GetEventHandlerForPoint(gfx::Point(1, 1)));
 }
 
 TEST_F(WindowTest, GetEventHandlerForPointWithOverrideDescendingOrder) {
   scoped_ptr<SelfEventHandlingWindowDelegate> parent_delegate(
       new SelfEventHandlingWindowDelegate);
   scoped_ptr<Window> parent(CreateTestWindowWithDelegate(
-      parent_delegate.get(), 1, gfx::Rect(10, 20, 400, 500), NULL));
+      parent_delegate.get(), 1, gfx::Rect(10, 20, 400, 500), root_window()));
   scoped_ptr<Window> child(
       CreateTestWindow(SK_ColorRED, 2, gfx::Rect(0, 0, 390, 480),
                        parent.get()));
 
   // We can override ShouldDescendIntoChildForEventHandling to make the parent
   // grab all events.
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(50, 50)));
 }
 
 TEST_F(WindowTest, GetTopWindowContainingPoint) {
   Window* root = root_window();
   root->SetBounds(gfx::Rect(0, 0, 300, 300));
 
   scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 100, 100), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 100, 100),
+                       root_window()));
   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));
+      CreateTestWindow(SK_ColorRED, 2, gfx::Rect(5, 5, 55, 55),
+                       root_window()));
 
   scoped_ptr<Window> w3(
       CreateTestWindowWithDelegate(
-          NULL, 3, gfx::Rect(200, 200, 100, 100), NULL));
+          NULL, 3, gfx::Rect(200, 200, 100, 100), root_window()));
   scoped_ptr<Window> w31(
       CreateTestWindow(SK_ColorCYAN, 31, gfx::Rect(0, 0, 50, 50), w3.get()));
   scoped_ptr<Window> w311(
       CreateTestWindow(SK_ColorBLUE, 311, gfx::Rect(0, 0, 10, 10), w31.get()));
 
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(0, 0)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(5, 5)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(10, 10)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(59, 59)));
   EXPECT_EQ(w1.get(), root->GetTopWindowContainingPoint(gfx::Point(60, 60)));
@@ skipping 34 matching lines @@
 
  private:
   bool called_;
 
   DISALLOW_COPY_AND_ASSIGN(AddedToRootWindowObserver);
 };
 
 TEST_F(WindowTest, WindowAddedToRootWindowShouldNotifyChildAndNotParent) {
   AddedToRootWindowObserver parent_observer;
   AddedToRootWindowObserver child_observer;
-  scoped_ptr<Window> parent_window(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> parent_window(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> child_window(new Window(NULL));
   child_window->Init(ui::LAYER_TEXTURED);
   child_window->Show();
 
   parent_window->AddObserver(&parent_observer);
   child_window->AddObserver(&child_observer);
 
   parent_window->AddChild(child_window.get());
 
   EXPECT_FALSE(parent_observer.called());
   EXPECT_TRUE(child_observer.called());
 
   parent_window->RemoveObserver(&parent_observer);
   child_window->RemoveObserver(&child_observer);
 }
 
 // Various destruction assertions.
 TEST_F(WindowTest, DestroyTest) {
   DestroyTrackingDelegateImpl parent_delegate;
   ChildWindowDelegateImpl child_delegate(&parent_delegate);
   {
     scoped_ptr<Window> parent(
-        CreateTestWindowWithDelegate(&parent_delegate, 0, gfx::Rect(), NULL));
+        CreateTestWindowWithDelegate(&parent_delegate, 0, gfx::Rect(),
+                                     root_window()));
     CreateTestWindowWithDelegate(&child_delegate, 0, gfx::Rect(), parent.get());
   }
   // Both the parent and child should have been destroyed.
   EXPECT_EQ(1, parent_delegate.destroying_count());
   EXPECT_EQ(1, parent_delegate.destroyed_count());
   EXPECT_EQ(1, child_delegate.destroying_count());
   EXPECT_EQ(1, child_delegate.destroyed_count());
 }
 
 // Tests that a window is orphaned before OnWindowDestroyed is called.
 TEST_F(WindowTest, OrphanedBeforeOnDestroyed) {
   TestWindowDelegate parent_delegate;
   DestroyOrphanDelegate child_delegate;
   {
     scoped_ptr<Window> parent(
-        CreateTestWindowWithDelegate(&parent_delegate, 0, gfx::Rect(), NULL));
+        CreateTestWindowWithDelegate(&parent_delegate, 0, gfx::Rect(),
+                                     root_window()));
     scoped_ptr<Window> child(CreateTestWindowWithDelegate(&child_delegate, 0,
           gfx::Rect(), parent.get()));
     child_delegate.set_window(child.get());
   }
 }
 
 // Make sure StackChildAtTop moves both the window and layer to the front.
 TEST_F(WindowTest, StackChildAtTop) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
 
-  child1.SetParent(&parent);
-  child2.SetParent(&parent);
+  parent.AddChild(&child1);
+  parent.AddChild(&child2);
   ASSERT_EQ(2u, parent.children().size());
   EXPECT_EQ(&child1, parent.children()[0]);
   EXPECT_EQ(&child2, parent.children()[1]);
   ASSERT_EQ(2u, parent.layer()->children().size());
   EXPECT_EQ(child1.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child2.layer(), parent.layer()->children()[1]);
 
   parent.StackChildAtTop(&child1);
   ASSERT_EQ(2u, parent.children().size());
   EXPECT_EQ(&child1, parent.children()[1]);
@@ skipping 10 matching lines @@
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   child1.set_id(1);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
   child2.set_id(2);
   Window child3(NULL);
   child3.Init(ui::LAYER_NOT_DRAWN);
   child3.set_id(3);
 
-  child1.SetParent(&parent);
-  child2.SetParent(&parent);
-  child3.SetParent(&parent);
+  parent.AddChild(&child1);
+  parent.AddChild(&child2);
+  parent.AddChild(&child3);
   EXPECT_EQ("1 2 3", ChildWindowIDsAsString(&parent));
 
   parent.StackChildBelow(&child1, &child2);
   EXPECT_EQ("1 2 3", ChildWindowIDsAsString(&parent));
 
   parent.StackChildBelow(&child2, &child1);
   EXPECT_EQ("2 1 3", ChildWindowIDsAsString(&parent));
 
   parent.StackChildBelow(&child3, &child2);
   EXPECT_EQ("3 2 1", ChildWindowIDsAsString(&parent));
 
   parent.StackChildBelow(&child3, &child1);
   EXPECT_EQ("2 3 1", ChildWindowIDsAsString(&parent));
 }
 
 // Various assertions for StackChildAbove.
 TEST_F(WindowTest, StackChildAbove) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
   Window child3(NULL);
   child3.Init(ui::LAYER_NOT_DRAWN);
 
-  child1.SetParent(&parent);
-  child2.SetParent(&parent);
+  parent.AddChild(&child1);
+  parent.AddChild(&child2);
 
   // Move 1 in front of 2.
   parent.StackChildAbove(&child1, &child2);
   ASSERT_EQ(2u, parent.children().size());
   EXPECT_EQ(&child2, parent.children()[0]);
   EXPECT_EQ(&child1, parent.children()[1]);
   ASSERT_EQ(2u, parent.layer()->children().size());
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
 
   // Add 3, resulting in order [2, 1, 3], then move 2 in front of 1, resulting
   // in [1, 2, 3].
-  child3.SetParent(&parent);
+  parent.AddChild(&child3);
   parent.StackChildAbove(&child2, &child1);
   ASSERT_EQ(3u, parent.children().size());
   EXPECT_EQ(&child1, parent.children()[0]);
   EXPECT_EQ(&child2, parent.children()[1]);
   EXPECT_EQ(&child3, parent.children()[2]);
   ASSERT_EQ(3u, parent.layer()->children().size());
   EXPECT_EQ(child1.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child2.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child3.layer(), parent.layer()->children()[2]);
 
@@ skipping 17 matching lines @@
   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 capture assertions.
 TEST_F(WindowTest, CaptureTests) {
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
-      &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
+      &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   EXPECT_FALSE(window->HasCapture());
 
   delegate.ResetCounts();
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
   EXPECT_EQ(0, delegate.capture_lost_count());
   EXPECT_EQ(0, delegate.capture_changed_event_count());
   EventGenerator generator(root_window(), gfx::Point(50, 50));
@@ skipping 30 matching lines @@
   window->SetCapture();
   EXPECT_EQ(window.get(), aura::client::GetCaptureWindow(root_window()));
   window->parent()->RemoveChild(window.get());
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
 TEST_F(WindowTest, TouchCaptureCancelsOtherTouches) {
   CaptureWindowDelegateImpl delegate1;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
-      &delegate1, 0, gfx::Rect(0, 0, 20, 20), NULL));
+      &delegate1, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   CaptureWindowDelegateImpl delegate2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
-      &delegate2, 0, gfx::Rect(20, 20, 20, 20), NULL));
+      &delegate2, 0, gfx::Rect(20, 20, 20, 20), root_window()));
 
   // Press on w1.
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate1.gesture_event_count());
   delegate1.ResetCounts();
   w2->SetCapture();
 
@@ skipping 24 matching lines @@
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   EXPECT_EQ(0, delegate1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate2.gesture_event_count());
 }
 
 TEST_F(WindowTest, TouchCaptureDoesntCancelCapturedTouches) {
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
-      &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
+      &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
 
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   window->SetCapture();
   EXPECT_EQ(0, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   // The move event should still create a gesture, as this touch was
   // on the window which was captured.
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
                              gfx::Point(10, 10), 0, getTime() +
                                  base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_EQ(2, delegate.gesture_event_count());
 }
 
 // Assertions around SetCapture() and touch/gestures.
 TEST_F(WindowTest, TransferCaptureTouchEvents) {
   // Touch on |w1|.
   CaptureWindowDelegateImpl d1;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
-      &d1, 0, gfx::Rect(0, 0, 20, 20), NULL));
+      &d1, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   ui::TouchEvent p1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&p1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, d1.gesture_event_count());
   d1.ResetCounts();
 
   // Touch on |w2| with a different id.
   CaptureWindowDelegateImpl d2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
-      &d2, 0, gfx::Rect(40, 0, 40, 20), NULL));
+      &d2, 0, gfx::Rect(40, 0, 40, 20), root_window()));
   ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::Point(41, 10), 1, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&p2);
   EXPECT_EQ(0, d1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN for new target window.
   EXPECT_EQ(2, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   // Set capture on |w2|, this should send a cancel (TAP_CANCEL, END) to |w1|
   // but not |w2|.
   w2->SetCapture();
   EXPECT_EQ(2, d1.gesture_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   CaptureWindowDelegateImpl d3;
   scoped_ptr<Window> w3(CreateTestWindowWithDelegate(
-                            &d3, 0, gfx::Rect(0, 0, 100, 101), NULL));
+      &d3, 0, gfx::Rect(0, 0, 100, 101), root_window()));
   // Set capture on w3. No new events should be received.
   w3->SetCapture();
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 
   // Move touch id originally associated with |w2|. Since capture was transfered
   // from 2 to 3 only |w3| should get the event.
   ui::TouchEvent m3(ui::ET_TOUCH_MOVED, gfx::Point(110, 105), 1, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&m3);
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   // |w3| gets a TAP_CANCEL and two scroll related events.
   EXPECT_EQ(3, d3.gesture_event_count());
 }
 
 // Changes capture while capture is already ongoing.
 TEST_F(WindowTest, ChangeCaptureWhileMouseDown) {
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
-      &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
+      &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   CaptureWindowDelegateImpl delegate2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
-      &delegate2, 0, gfx::Rect(20, 20, 20, 20), NULL));
+      &delegate2, 0, gfx::Rect(20, 20, 20, 20), root_window()));
 
   // Execute the scheduled draws so that mouse events are not
   // aggregated.
   RunAllPendingInMessageLoop();
 
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   delegate.ResetCounts();
   window->SetCapture();
@@ skipping 15 matching lines @@
   EXPECT_EQ(1, delegate.capture_lost_count());
   EXPECT_EQ(1, delegate.capture_changed_event_count());
   EXPECT_EQ(1, delegate.mouse_event_count());
   EXPECT_EQ(2, delegate2.mouse_event_count());
 }
 
 // Verifies capture is reset when a window is destroyed.
 TEST_F(WindowTest, ReleaseCaptureOnDestroy) {
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
-      &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
+      &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
 
   // Destroy the window.
   window.reset();
 
   // Make sure the root window doesn't reference the window anymore.
   EXPECT_EQ(NULL, root_window()->mouse_pressed_handler());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
 TEST_F(WindowTest, GetBoundsInRootWindow) {
   scoped_ptr<Window> viewport(CreateTestWindowWithBounds(
-      gfx::Rect(0, 0, 300, 300), NULL));
+      gfx::Rect(0, 0, 300, 300), root_window()));
   scoped_ptr<Window> child(CreateTestWindowWithBounds(
       gfx::Rect(0, 0, 100, 100), viewport.get()));
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window's screen bounds should move along with the |viewport|.
   viewport->SetBounds(gfx::Rect(-100, -100, 300, 300));
   EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window is moved to the 0,0 in screen coordinates.
@@ skipping 35 matching lines @@
 
   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) {
   MouseEnterExitWindowDelegate d1;
   scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
+                                   root_window()));
   MouseEnterExitWindowDelegate d2;
   scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50),
+                                   root_window()));
 
   test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   generator.MoveMouseToCenterOf(w2.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 #if !defined(OS_WIN)
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window, even if the entered window sets
 // and releases capture.
 TEST_F(WindowTest, MouseEnterExitWithClick) {
   MouseEnterExitWindowDelegate d1;
   scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
+                                   root_window()));
   MouseEnterExitWindowDelegate d2;
   scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50),
+                                   root_window()));
 
   test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   // Emmulate what Views does on a click by grabbing and releasing capture.
   generator.PressLeftButton();
   w1->SetCapture();
   w1->ReleaseCapture();
   generator.ReleaseLeftButton();
 
   generator.MoveMouseToCenterOf(w2.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 // Temporarily disabled for windows. See crbug.com/112222.
 // Verifies that enter / exits are sent if windows appear and are deleted
 // under the current mouse position..
 TEST_F(WindowTest, MouseEnterExitWithDelete) {
   MouseEnterExitWindowDelegate d1;
   scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
+                                   root_window()));
 
   test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
 
   {
     MouseEnterExitWindowDelegate d2;
     scoped_ptr<Window> w2(
-        CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50), NULL));
+        CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
+                                     root_window()));
     // Enters / exits can be send asynchronously.
     RunAllPendingInMessageLoop();
     EXPECT_TRUE(d1.entered());
     EXPECT_TRUE(d1.exited());
     EXPECT_TRUE(d2.entered());
     EXPECT_FALSE(d2.exited());
     d1.ResetExpectations();
   }
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d1.entered());
 }
 
 // Verifies that enter / exits are sent if windows appear and are hidden
 // under the current mouse position..
 TEST_F(WindowTest, MouseEnterExitWithHide) {
   MouseEnterExitWindowDelegate d1;
   scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
+                                   root_window()));
 
   test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
 
   MouseEnterExitWindowDelegate d2;
   scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
+                                   root_window()));
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   d1.ResetExpectations();
   w2->Hide();
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d1.entered());
 }
 #endif
 
 // 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
 // GetEventHandlerForPoint() skips w12 even though its bounds contain the event,
 // because it has no children that can handle the event and it has no delegate
 // allowing it to handle the event itself.
 TEST_F(WindowTest, GetEventHandlerForPoint_NoDelegate) {
   TestWindowDelegate d111;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(NULL, 1,
-      gfx::Rect(0, 0, 500, 500), NULL));
+      gfx::Rect(0, 0, 500, 500), root_window()));
   scoped_ptr<Window> w11(CreateTestWindowWithDelegate(NULL, 11,
       gfx::Rect(0, 0, 500, 500), w1.get()));
   scoped_ptr<Window> w111(CreateTestWindowWithDelegate(&d111, 111,
       gfx::Rect(50, 50, 450, 450), w11.get()));
   scoped_ptr<Window> w12(CreateTestWindowWithDelegate(NULL, 12,
       gfx::Rect(0, 0, 500, 500), w1.get()));
 
   gfx::Point target_point = w111->bounds().CenterPoint();
   EXPECT_EQ(w111.get(), w1->GetEventHandlerForPoint(target_point));
 }
@@ skipping 23 matching lines @@
   int shown_;
   int hidden_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityWindowDelegate);
 };
 
 // Verifies show/hide propagate correctly to children and the layer.
 TEST_F(WindowTest, Visibility) {
   VisibilityWindowDelegate d;
   VisibilityWindowDelegate d2;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(&d, 1, gfx::Rect(), NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(&d, 1, gfx::Rect(),
+                                                     root_window()));
   scoped_ptr<Window> w2(
       CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(),  w1.get()));
   scoped_ptr<Window> w3(CreateTestWindowWithId(3, w2.get()));
 
   // Create shows all the windows.
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_TRUE(w3->IsVisible());
   EXPECT_EQ(1, d.shown());
 
@@ skipping 40 matching lines @@
   EXPECT_EQ(0, d2.hidden());
   EXPECT_EQ(1, d2.shown());
 }
 
 TEST_F(WindowTest, IgnoreEventsTest) {
   TestWindowDelegate d11;
   TestWindowDelegate d12;
   TestWindowDelegate d111;
   TestWindowDelegate d121;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(NULL, 1,
-      gfx::Rect(0, 0, 500, 500), NULL));
+      gfx::Rect(0, 0, 500, 500), root_window()));
   scoped_ptr<Window> w11(CreateTestWindowWithDelegate(&d11, 11,
       gfx::Rect(0, 0, 500, 500), w1.get()));
   scoped_ptr<Window> w111(CreateTestWindowWithDelegate(&d111, 111,
       gfx::Rect(50, 50, 450, 450), w11.get()));
   scoped_ptr<Window> w12(CreateTestWindowWithDelegate(&d12, 12,
       gfx::Rect(0, 0, 500, 500), w1.get()));
   scoped_ptr<Window> w121(CreateTestWindowWithDelegate(&d121, 121,
       gfx::Rect(150, 150, 50, 50), w12.get()));
 
   EXPECT_EQ(w12.get(), w1->GetEventHandlerForPoint(gfx::Point(10, 10)));
@@ skipping 36 matching lines @@
   EXPECT_EQ(size.ToString(),
             root_window()->GetHostSize().ToString());
 }
 
 TEST_F(WindowTest, TransformGesture) {
   gfx::Size size = root_window()->GetHostSize();
 
   scoped_ptr<GestureTrackPositionDelegate> delegate(
       new GestureTrackPositionDelegate);
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(delegate.get(), -1234,
-      gfx::Rect(0, 0, 20, 20), NULL));
+      gfx::Rect(0, 0, 20, 20), root_window()));
 
   // Rotate the root-window clock-wise 90 degrees.
   gfx::Transform transform;
   transform.SetRotate(90.0f);
   transform.ConcatTranslate(size.height(), 0);
   root_window()->SetTransform(transform);
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_EQ(gfx::Point(10, 10).ToString(), delegate->position().ToString());
 }
 
 // Various assertions for transient children.
 TEST_F(WindowTest, TransientChildren) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, NULL));
+  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
   scoped_ptr<Window> w3(CreateTestWindowWithId(3, parent.get()));
   Window* w2 = CreateTestWindowWithId(2, parent.get());
   w1->AddTransientChild(w2);  // w2 is now owned by w1.
   // Stack w1 at the top (end), this should force w2 to be last (on top of w1).
   parent->StackChildAtTop(w1.get());
   ASSERT_EQ(3u, parent->children().size());
   EXPECT_EQ(w2, parent->children().back());
 
   // Destroy w1, which should also destroy w3 (since it's a transient child).
@@ skipping 14 matching lines @@
   EXPECT_EQ(w1.get(), parent->children()[1]);
 
   // Hiding parent should hide transient children.
   EXPECT_TRUE(w2->IsVisible());
   w1->Hide();
   EXPECT_FALSE(w2->IsVisible());
 }
 
 // Tests that when a focused window is closed, its parent inherits the focus.
 TEST_F(WindowTest, FocusedWindowTest) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, NULL));
+  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
   scoped_ptr<Window> child(CreateTestWindowWithId(1, parent.get()));
 
   parent->Show();
 
   child->Focus();
   EXPECT_TRUE(child->HasFocus());
   EXPECT_FALSE(parent->HasFocus());
 
   child.reset();
   EXPECT_TRUE(parent->HasFocus());
 }
 
 // Tests that the previously-focused window is passed to
 // WindowDelegate::OnFocus().
 TEST_F(WindowTest, OldFocusedWindowTest) {
   const gfx::Rect kBounds(0, 0, 100, 100);
 
   FocusDelegate delegate1;
   scoped_ptr<Window> window1(
-      CreateTestWindowWithDelegate(&delegate1, 0, kBounds, NULL));
+      CreateTestWindowWithDelegate(&delegate1, 0, kBounds, root_window()));
   window1->Focus();
   ASSERT_TRUE(window1->HasFocus());
   EXPECT_TRUE(delegate1.previous_focused_window() == NULL);
 
   FocusDelegate delegate2;
   scoped_ptr<Window> window2(
-      CreateTestWindowWithDelegate(&delegate2, 1, kBounds, NULL));
+      CreateTestWindowWithDelegate(&delegate2, 1, kBounds, root_window()));
   window2->Focus();
   ASSERT_TRUE(window2->HasFocus());
   EXPECT_FALSE(window1->HasFocus());
   EXPECT_EQ(window1.get(), delegate2.previous_focused_window());
 }
 
 namespace {
 DEFINE_WINDOW_PROPERTY_KEY(int, kIntKey, -2);
 DEFINE_WINDOW_PROPERTY_KEY(const char*, kStringKey, "squeamish");
 }
 
 TEST_F(WindowTest, Property) {
-  scoped_ptr<Window> w(CreateTestWindowWithId(0, NULL));
+  scoped_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
 
   static const char native_prop_key[] = "fnord";
 
   // Non-existent properties should return the default values.
   EXPECT_EQ(-2, w->GetProperty(kIntKey));
   EXPECT_EQ(std::string("squeamish"), w->GetProperty(kStringKey));
   EXPECT_EQ(NULL, w->GetNativeWindowProperty(native_prop_key));
 
   // A set property value should be returned again (even if it's the default
   // value).
@@ skipping 38 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestProperty);
 };
 
 TestProperty* TestProperty::last_deleted_ = NULL;
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(TestProperty, kOwnedKey, NULL);
 
 }  // namespace
 
 TEST_F(WindowTest, OwnedProperty) {
-  scoped_ptr<Window> w(CreateTestWindowWithId(0, NULL));
+  scoped_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
   EXPECT_EQ(NULL, w->GetProperty(kOwnedKey));
   TestProperty* p1 = new TestProperty();
   w->SetProperty(kOwnedKey, p1);
   EXPECT_EQ(p1, w->GetProperty(kOwnedKey));
   EXPECT_EQ(NULL, TestProperty::last_deleted());
 
   TestProperty* p2 = new TestProperty();
   w->SetProperty(kOwnedKey, p2);
   EXPECT_EQ(p2, w->GetProperty(kOwnedKey));
   EXPECT_EQ(p1, TestProperty::last_deleted());
 
   w->ClearProperty(kOwnedKey);
   EXPECT_EQ(NULL, w->GetProperty(kOwnedKey));
   EXPECT_EQ(p2, TestProperty::last_deleted());
 
   TestProperty* p3 = new TestProperty();
   w->SetProperty(kOwnedKey, p3);
   EXPECT_EQ(p3, w->GetProperty(kOwnedKey));
   EXPECT_EQ(p2, TestProperty::last_deleted());
   w.reset();
   EXPECT_EQ(p3, TestProperty::last_deleted());
 }
 
 TEST_F(WindowTest, SetBoundsInternalShouldCheckTargetBounds) {
   // We cannot short-circuit animations in this test.
   ui::LayerAnimator::set_disable_animations_for_test(false);
 
   scoped_ptr<Window> w1(
-      CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), NULL));
+      CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), root_window()));
 
   EXPECT_FALSE(!w1->layer());
   w1->layer()->GetAnimator()->set_disable_timer_for_test(true);
   ui::AnimationContainerElement* element = w1->layer()->GetAnimator();
 
   EXPECT_EQ("0,0 100x100", w1->bounds().ToString());
   EXPECT_EQ("0,0 100x100", w1->layer()->GetTargetBounds().ToString());
 
   // Animate to a different position.
   {
@@ skipping 109 matching lines @@
   int destroyed_count_;
   scoped_ptr<VisibilityInfo> visibility_info_;
   const void* property_key_;
   intptr_t old_property_value_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserverTest);
 };
 
 // Various assertions for WindowObserver.
 TEST_F(WindowObserverTest, WindowObserver) {
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   // Create a new window as a child of w1, our observer should be notified.
   scoped_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
   EXPECT_EQ("added=1 removed=0", WindowObserverCountStateAndClear());
 
   // Delete w2, which should result in the remove notification.
   w2.reset();
   EXPECT_EQ("added=0 removed=1", WindowObserverCountStateAndClear());
 
   // Create a window that isn't parented to w1, we shouldn't get any
   // notification.
-  scoped_ptr<Window> w3(CreateTestWindowWithId(3, NULL));
+  scoped_ptr<Window> w3(CreateTestWindowWithId(3, root_window()));
   EXPECT_EQ("added=0 removed=0", WindowObserverCountStateAndClear());
 
   // Similarly destroying w3 shouldn't notify us either.
   w3.reset();
   EXPECT_EQ("added=0 removed=0", WindowObserverCountStateAndClear());
   w1->RemoveObserver(this);
 }
 
 // Test if OnWindowVisibilityChagned is invoked with expected
 // parameters.
 TEST_F(WindowObserverTest, WindowVisibility) {
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> w2(CreateTestWindowWithId(1, w1.get()));
   w2->AddObserver(this);
 
   // Hide should make the window invisible and the passed visible
   // parameter is false.
   w2->Hide();
   EXPECT_FALSE(!GetVisibilityInfo());
   EXPECT_FALSE(!GetVisibilityInfo());
   if (!GetVisibilityInfo())
     return;
@@ skipping 21 matching lines @@
   EXPECT_FALSE(!GetVisibilityInfo());
   if (!GetVisibilityInfo())
     return;
   EXPECT_TRUE(GetVisibilityInfo()->window_visible);
   EXPECT_TRUE(GetVisibilityInfo()->visible_param);
 }
 
 // Test if OnWindowDestroyed is invoked as expected.
 TEST_F(WindowObserverTest, WindowDestroyed) {
   // Delete a window should fire a destroyed notification.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
   w1.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 
   // Observe on child and delete parent window should fire a notification.
-  scoped_ptr<Window> parent(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> parent(CreateTestWindowWithId(1, root_window()));
   Window* child = CreateTestWindowWithId(1, parent.get());  // owned by parent
   child->AddObserver(this);
   parent.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 }
 
 TEST_F(WindowObserverTest, PropertyChanged) {
   // Setting property should fire a property change notification.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   static const WindowProperty<int> prop = {-2};
   static const char native_prop_key[] = "fnord";
 
   w1->SetProperty(&prop, 1);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), PropertyChangeInfoAndClear());
   w1->SetProperty(&prop, -2);
   EXPECT_EQ(PropertyChangeInfo(&prop, 1), PropertyChangeInfoAndClear());
   w1->SetProperty(&prop, 3);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), PropertyChangeInfoAndClear());
   w1->ClearProperty(&prop);
   EXPECT_EQ(PropertyChangeInfo(&prop, 3), PropertyChangeInfoAndClear());
 
   w1->SetNativeWindowProperty(native_prop_key, &*w1);
   EXPECT_EQ(PropertyChangeInfo(native_prop_key, 0),
             PropertyChangeInfoAndClear());
   w1->SetNativeWindowProperty(native_prop_key, NULL);
   EXPECT_EQ(PropertyChangeInfo(native_prop_key,
                                reinterpret_cast<intptr_t>(&*w1)),
             PropertyChangeInfoAndClear());
 
   // Sanity check to see if |PropertyChangeInfoAndClear| really clears.
   EXPECT_EQ(PropertyChangeInfo(
       reinterpret_cast<const void*>(NULL), -3), PropertyChangeInfoAndClear());
 }
 
 TEST_F(WindowTest, AcquireLayer) {
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, NULL));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, NULL));
+  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
+  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
   ui::Layer* parent = window1->parent()->layer();
   EXPECT_EQ(2U, parent->children().size());
 
   Window::TestApi window1_test_api(window1.get());
   Window::TestApi window2_test_api(window2.get());
 
   EXPECT_TRUE(window1_test_api.OwnsLayer());
   EXPECT_TRUE(window2_test_api.OwnsLayer());
 
   // After acquisition, window1 should not own its layer, but it should still
@@ skipping 33 matching lines @@
   EXPECT_EQ(ui::LAYER_SOLID_COLOR, layer->type());
   EXPECT_FALSE(layer->scale_content());
   EXPECT_FALSE(layer->visible());
   EXPECT_EQ(1u, layer->children().size());
 }
 
 // Ensure that acquiring a layer then recreating a layer does not crash
 // and that RecreateLayer returns null.
 TEST_F(WindowTest, AcquireThenRecreateLayer) {
   scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100), NULL));
+      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100),
+                       root_window()));
   scoped_ptr<ui::Layer>acquired_layer(w->AcquireLayer());
   scoped_ptr<ui::Layer>doubly_acquired_layer(w->RecreateLayer());
   EXPECT_EQ(NULL, doubly_acquired_layer.get());
 
   // Destroy window before layer gets destroyed.
   w.reset();
 }
 
 TEST_F(WindowTest, StackWindowsWhoseLayersHaveNoDelegate) {
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, NULL));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, NULL));
+  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
+  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
 
   // This brings window1 (and its layer) to the front.
   root_window()->StackChildAbove(window1.get(), window2.get());
   EXPECT_EQ(root_window()->children().front(), window2.get());
   EXPECT_EQ(root_window()->children().back(), window1.get());
   EXPECT_EQ(root_window()->layer()->children().front(), window2->layer());
   EXPECT_EQ(root_window()->layer()->children().back(), window1->layer());
 
   // Since window1 does not have a delegate, window2 should not move in
   // front of it, nor should its layer.
   window1->layer()->set_delegate(NULL);
   root_window()->StackChildAbove(window2.get(), window1.get());
   EXPECT_EQ(root_window()->children().front(), window2.get());
   EXPECT_EQ(root_window()->children().back(), window1.get());
   EXPECT_EQ(root_window()->layer()->children().front(), window2->layer());
   EXPECT_EQ(root_window()->layer()->children().back(), window1->layer());
 }
 
 TEST_F(WindowTest, StackTransientsWhoseLayersHaveNoDelegate) {
   RootWindow* root = root_window();
 
   // Create a window with several transients, then a couple windows on top.
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> window11(CreateTransientChild(11, window1.get()));
   scoped_ptr<Window> window12(CreateTransientChild(12, window1.get()));
   scoped_ptr<Window> window13(CreateTransientChild(13, window1.get()));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, NULL));
-  scoped_ptr<Window> window3(CreateTestWindowWithId(3, NULL));
+  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
+  scoped_ptr<Window> window3(CreateTestWindowWithId(3, root_window()));
 
   EXPECT_EQ("1 11 12 13 2 3", ChildWindowIDsAsString(root));
 
   // Remove the delegates of a couple of transients, as if they are closing
   // and animating out.
   window11->layer()->set_delegate(NULL);
   window13->layer()->set_delegate(NULL);
 
   // Move window1 to the front.  All transients should move with it, and their
   // order should be preserved.
@@ skipping 23 matching lines @@
   }
 
  private:
   bool ignore_visibility_changes_;
   DISALLOW_COPY_AND_ASSIGN(TestVisibilityClient);
 };
 
 TEST_F(WindowTest, VisibilityClientIsVisible) {
   TestVisibilityClient client(root_window());
 
-  scoped_ptr<Window> window(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
   EXPECT_TRUE(window->IsVisible());
   EXPECT_TRUE(window->layer()->visible());
 
   window->Hide();
   EXPECT_FALSE(window->IsVisible());
   EXPECT_FALSE(window->layer()->visible());
   window->Show();
 
   client.set_ignore_visibility_changes(true);
   window->Hide();
@@ skipping 165 matching lines @@
 // should not be adjusted.
 // One issue that can arise when a window opens two transient children, and the
 // first is hidden. Subsequent attempts to activate the transient parent can
 // result in the transient parent being stacked above the second transient
 // child. A fix is made to Window::StackAbove to prevent this, and this test
 // verifies this fix.
 TEST_F(WindowTest, StackingMadrigal) {
   new StackingMadrigalLayoutManager(root_window());
   StackingMadrigalVisibilityClient visibility_client(root_window());
 
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> window11(CreateTransientChild(11, window1.get()));
 
   visibility_client.set_ignored_window(window11.get());
 
   window11->Show();
   window11->Hide();
 
   // As a transient, window11 should still be stacked above window1, even when
   // hidden.
   EXPECT_TRUE(WindowIsAbove(window11.get(), window1.get()));
@@ skipping 17 matching lines @@
 
   // Both window12 and its layer should be stacked above window1.
   EXPECT_TRUE(WindowIsAbove(window12.get(), window1.get()));
   EXPECT_TRUE(LayerIsAbove(window12.get(), window1.get()));
 }
 
 // Test for an issue where attempting to stack a primary window on top of a
 // transient with a NULL layer delegate causes that primary window to be moved,
 // but the layer order not changed to match.  http://crbug.com/112562
 TEST_F(WindowTest, StackOverClosingTransient) {
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> transient1(CreateTransientChild(11, window1.get()));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, NULL));
+  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
   scoped_ptr<Window> transient2(CreateTransientChild(21, window2.get()));
 
   // Both windows and layers are stacked in creation order.
   RootWindow* root = root_window();
   ASSERT_EQ(4u, root->children().size());
   EXPECT_EQ(root->children()[0], window1.get());
   EXPECT_EQ(root->children()[1], transient1.get());
   EXPECT_EQ(root->children()[2], window2.get());
   EXPECT_EQ(root->children()[3], transient2.get());
   ASSERT_EQ(4u, root->layer()->children().size());
@@ skipping 36 matching lines @@
   ASSERT_EQ(3u, root->children().size());
   EXPECT_EQ(root->children()[0], window1.get());
   EXPECT_EQ(root->children()[1], window2.get());
   EXPECT_EQ(root->children()[2], transient2.get());
   ASSERT_EQ(3u, root->layer()->children().size());
   EXPECT_EQ(root->layer()->children()[0], window1->layer());
   EXPECT_EQ(root->layer()->children()[1], window2->layer());
   EXPECT_EQ(root->layer()->children()[2], transient2->layer());
 
   // Open another window on top.
-  scoped_ptr<Window> window3(CreateTestWindowWithId(3, NULL));
+  scoped_ptr<Window> window3(CreateTestWindowWithId(3, root_window()));
 
   ASSERT_EQ(4u, root->children().size());
   EXPECT_EQ(root->children()[0], window1.get());
   EXPECT_EQ(root->children()[1], window2.get());
   EXPECT_EQ(root->children()[2], transient2.get());
   EXPECT_EQ(root->children()[3], window3.get());
   ASSERT_EQ(4u, root->layer()->children().size());
   EXPECT_EQ(root->layer()->children()[0], window1->layer());
   EXPECT_EQ(root->layer()->children()[1], window2->layer());
   EXPECT_EQ(root->layer()->children()[2], transient2->layer());
@@ skipping 60 matching lines @@
 };
 
 TEST_F(WindowTest, RootWindowAttachment) {
   RootWindowAttachmentObserver observer;
 
   // Test a direct add/remove from the RootWindow.
   scoped_ptr<Window> w1(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   w1->AddObserver(&observer);
 
-  w1->SetParent(NULL);
+  AddToRootWindow(w1.get());
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
   w1.reset();
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(1, observer.removed_count());
 
   observer.Clear();
 
   // Test an indirect add/remove from the RootWindow.
   w1.reset(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   Window* w11 = new Window(NULL);
   w11->Init(ui::LAYER_NOT_DRAWN);
   w11->AddObserver(&observer);
-  w11->SetParent(w1.get());
+  w1->AddChild(w11);
   EXPECT_EQ(0, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
-  w1->SetParent(NULL);
+  AddToRootWindow(w1.get());
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
   w1.reset();  // Deletes w11.
   w11 = NULL;
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(1, observer.removed_count());
 
   observer.Clear();
 
   // Test an indirect add/remove with nested observers.
   w1.reset(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   w11 = new Window(NULL);
   w11->Init(ui::LAYER_NOT_DRAWN);
   w11->AddObserver(&observer);
-  w11->SetParent(w1.get());
+  w1->AddChild(w11);
   Window* w111 = new Window(NULL);
   w111->Init(ui::LAYER_NOT_DRAWN);
   w111->AddObserver(&observer);
-  w111->SetParent(w11);
+  w11->AddChild(w111);
 
   EXPECT_EQ(0, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
-  w1->SetParent(NULL);
+  AddToRootWindow(w1.get());
   EXPECT_EQ(2, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
   w1.reset();  // Deletes w11 and w111.
   w11 = NULL;
   w111 = NULL;
   EXPECT_EQ(2, observer.added_count());
   EXPECT_EQ(2, observer.removed_count());
 }
 
 TEST_F(WindowTest, OwnedByParentFalse) {
   // By default, a window is owned by its parent. If this is set to false, the
   // window will not be destroyed when its parent is.
 
   scoped_ptr<Window> w1(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   scoped_ptr<Window> w2(new Window(NULL));
   w2->set_owned_by_parent(false);
   w2->Init(ui::LAYER_NOT_DRAWN);
-  w2->SetParent(w1.get());
+  w1->AddChild(w2.get());
 
   w1.reset();
 
   // We should be able to deref w2 still, but its parent should now be NULL.
   EXPECT_EQ(NULL, w2->parent());
 }
 
 namespace {
 
 // Used By DeleteWindowFromOnWindowDestroyed. Destroys a Window from
@@ skipping 22 matching lines @@
 // destroyed (WindowDelegate::OnWindowDestroyed) it deletes the second child.
 // This synthesizes BrowserView and the status bubble. Both are children of the
 // same parent and destroying BrowserView triggers it destroying the status
 // bubble.
 TEST_F(WindowTest, DeleteWindowFromOnWindowDestroyed) {
   scoped_ptr<Window> parent(new Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   OwningWindowDelegate delegate;
   Window* c1 = new Window(&delegate);
   c1->Init(ui::LAYER_NOT_DRAWN);
-  c1->SetParent(parent.get());
+  parent->AddChild(c1);
   Window* c2 = new Window(NULL);
   c2->Init(ui::LAYER_NOT_DRAWN);
-  c2->SetParent(parent.get());
+  parent->AddChild(c2);
   delegate.SetOwnedWindow(c2);
   parent.reset();
 }
 
 namespace {
 
 // Used by DelegateNotifiedAsBoundsChange to verify OnBoundsChanged() is
 // invoked.
 class BoundsChangeDelegate : public TestWindowDelegate {
  public:
@@ skipping 22 matching lines @@
 // Verifies the delegate is notified when the actual bounds of the layer
 // change.
 TEST_F(WindowTest, DelegateNotifiedAsBoundsChange) {
   BoundsChangeDelegate delegate;
 
   // We cannot short-circuit animations in this test.
   ui::LayerAnimator::set_disable_animations_for_test(false);
 
   scoped_ptr<Window> window(
       CreateTestWindowWithDelegate(&delegate, 1,
-                                   gfx::Rect(0, 0, 100, 100), NULL));
+                                   gfx::Rect(0, 0, 100, 100), root_window()));
   window->layer()->GetAnimator()->set_disable_timer_for_test(true);
 
   delegate.clear_bounds_changed();
 
   // Animate to a different position.
   {
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     window->SetBounds(gfx::Rect(100, 100, 100, 100));
   }
 
@@ skipping 13 matching lines @@
 // Verifies the delegate is notified when the actual bounds of the layer
 // change even when the window is not the layer's delegate
 TEST_F(WindowTest, DelegateNotifiedAsBoundsChangeInHiddenLayer) {
   BoundsChangeDelegate delegate;
 
   // We cannot short-circuit animations in this test.
   ui::LayerAnimator::set_disable_animations_for_test(false);
 
   scoped_ptr<Window> window(
       CreateTestWindowWithDelegate(&delegate, 1,
-                                   gfx::Rect(0, 0, 100, 100), NULL));
+                                   gfx::Rect(0, 0, 100, 100), root_window()));
   window->layer()->GetAnimator()->set_disable_timer_for_test(true);
 
   delegate.clear_bounds_changed();
 
   // Suppress paint on the window since it is hidden (should reset the layer's
   // delegate to NULL)
   window->SuppressPaint();
   EXPECT_EQ(NULL, window->layer()->delegate());
 
   // Animate to a different position.
@@ skipping 47 matching lines @@
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AddChildNotificationsObserver);
 };
 
 }  // namespace
 
 // Assertions around when root window notifications are sent.
 TEST_F(WindowTest, AddChildNotifications) {
   AddChildNotificationsObserver observer;
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
-  scoped_ptr<Window> w2(CreateTestWindowWithId(1, NULL));
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  scoped_ptr<Window> w2(CreateTestWindowWithId(1, root_window()));
   w2->AddObserver(&observer);
   w2->Focus();
   EXPECT_TRUE(w2->HasFocus());
 
   // Move |w2| to be a child of |w1|.
   w1->AddChild(w2.get());
   // Sine we moved in the same root, observer shouldn't be notified.
   EXPECT_EQ("0 0", observer.CountStringAndReset());
   // |w2| should still have focus after moving.
   EXPECT_TRUE(w2->HasFocus());
 }
 
 }  // namespace test
 }  // namespace aura