Makes Window::Init take a WindowLayerType instead of LayerType.

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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 250 matching lines @@
 
   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);
+  parent.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child1(NULL);
-  child1.Init(ui::LAYER_NOT_DRAWN);
+  child1.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child2(NULL);
-  child2.Init(ui::LAYER_NOT_DRAWN);
+  child2.Init(aura::WINDOW_LAYER_NOT_DRAWN);
 
   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));
@@ skipping 180 matching lines @@
   EXPECT_TRUE(dispatcher()->host()->QueryMouseLocation(&mouse_location));
   EXPECT_EQ("169,80", mouse_location.ToString());
 #endif
   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.Init(aura::WINDOW_LAYER_TEXTURED);
   w1.SetBounds(gfx::Rect(10, 20, 50, 60));
   w1.Show();
   ParentWindow(&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),
@@ skipping 11 matching lines @@
       ui::ET_TOUCH_RELEASED, gfx::Point(50, 50), 0, getTime());
   dispatcher()->AsRootWindowHostDelegate()->OnHostTouchEvent(&released);
   EXPECT_FALSE(w1.HitTest(gfx::Point(-2, -2)));
 
   // 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.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   w1.SetBounds(gfx::Rect(10, 20, 50, 60));
   w1.Show();
   ParentWindow(&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.
@@ skipping 133 matching lines @@
   bool called_;
 
   DISALLOW_COPY_AND_ASSIGN(AddedToRootWindowObserver);
 };
 
 TEST_F(WindowTest, WindowAddedToRootWindowShouldNotifyChildAndNotParent) {
   AddedToRootWindowObserver parent_observer;
   AddedToRootWindowObserver child_observer;
   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->Init(aura::WINDOW_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());
 
@@ skipping 28 matching lines @@
                                      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);
+  parent.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child1(NULL);
-  child1.Init(ui::LAYER_NOT_DRAWN);
+  child1.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child2(NULL);
-  child2.Init(ui::LAYER_NOT_DRAWN);
+  child2.Init(aura::WINDOW_LAYER_NOT_DRAWN);
 
   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]);
   EXPECT_EQ(&child2, parent.children()[0]);
   ASSERT_EQ(2u, parent.layer()->children().size());
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
 }
 
 // Make sure StackChildBelow works.
 TEST_F(WindowTest, StackChildBelow) {
   Window parent(NULL);
-  parent.Init(ui::LAYER_NOT_DRAWN);
+  parent.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child1(NULL);
-  child1.Init(ui::LAYER_NOT_DRAWN);
+  child1.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   child1.set_id(1);
   Window child2(NULL);
-  child2.Init(ui::LAYER_NOT_DRAWN);
+  child2.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   child2.set_id(2);
   Window child3(NULL);
-  child3.Init(ui::LAYER_NOT_DRAWN);
+  child3.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   child3.set_id(3);
 
   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);
+  parent.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child1(NULL);
-  child1.Init(ui::LAYER_NOT_DRAWN);
+  child1.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child2(NULL);
-  child2.Init(ui::LAYER_NOT_DRAWN);
+  child2.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window child3(NULL);
-  child3.Init(ui::LAYER_NOT_DRAWN);
+  child3.Init(aura::WINDOW_LAYER_NOT_DRAWN);
 
   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());
@@ skipping 1157 matching lines @@
   EXPECT_TRUE(window1_layer->delegate() == NULL);
   EXPECT_EQ(1U, parent->children().size());
 }
 
 // Make sure that properties which should persist from the old layer to the new
 // layer actually do.
 TEST_F(WindowTest, RecreateLayer) {
   // Set properties to non default values.
   Window w(new ColorTestWindowDelegate(SK_ColorWHITE));
   w.set_id(1);
-  w.Init(ui::LAYER_SOLID_COLOR);
+  w.Init(aura::WINDOW_LAYER_SOLID_COLOR);
   w.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   ui::Layer* layer = w.layer();
   layer->set_scale_content(false);
   layer->SetVisible(false);
   layer->SetMasksToBounds(true);
 
   ui::Layer child_layer;
   layer->Add(&child_layer);
 
@@ skipping 218 matching lines @@
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowAttachmentObserver);
 };
 
 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->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   w1->AddObserver(&observer);
 
   ParentWindow(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);
+  w1->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   Window* w11 = new Window(NULL);
-  w11->Init(ui::LAYER_NOT_DRAWN);
+  w11->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   w11->AddObserver(&observer);
   w1->AddChild(w11);
   EXPECT_EQ(0, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
   ParentWindow(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);
+  w1->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   w11 = new Window(NULL);
-  w11->Init(ui::LAYER_NOT_DRAWN);
+  w11->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   w11->AddObserver(&observer);
   w1->AddChild(w11);
   Window* w111 = new Window(NULL);
-  w111->Init(ui::LAYER_NOT_DRAWN);
+  w111->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   w111->AddObserver(&observer);
   w11->AddChild(w111);
 
   EXPECT_EQ(0, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
   ParentWindow(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);
+  w1->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   scoped_ptr<Window> w2(new Window(NULL));
   w2->set_owned_by_parent(false);
-  w2->Init(ui::LAYER_NOT_DRAWN);
+  w2->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   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 {
 
@@ skipping 19 matching lines @@
 
 }  // namespace
 
 // Creates a window with two child windows. When the first child window is
 // 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);
+  parent->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   OwningWindowDelegate delegate;
   Window* c1 = new Window(&delegate);
-  c1->Init(ui::LAYER_NOT_DRAWN);
+  c1->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   parent->AddChild(c1);
   Window* c2 = new Window(NULL);
-  c2->Init(ui::LAYER_NOT_DRAWN);
+  c2->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   parent->AddChild(c2);
   delegate.SetOwnedWindow(c2);
   parent.reset();
 }
 
 namespace {
 
 // Used by DelegateNotifiedAsBoundsChange to verify OnBoundsChanged() is
 // invoked.
 class BoundsChangeDelegate : public TestWindowDelegate {
@@ skipping 356 matching lines @@
     w1.reset();
     w2.reset();
   }
 
 }
 
 // Verifies SchedulePaint() on a layerless window results in damaging the right
 // thing.
 TEST_F(WindowTest, LayerlessWindowSchedulePaint) {
   Window root(NULL);
-  root.Init(ui::LAYER_NOT_DRAWN);
+  root.Init(aura::WINDOW_LAYER_NOT_DRAWN);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   Window* layerless_window = new Window(NULL);  // Owned by |root|.
-  layerless_window->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  layerless_window->Init(WINDOW_LAYER_NONE);
   layerless_window->SetBounds(gfx::Rect(10, 11, 12, 13));
   root.AddChild(layerless_window);
 
   root.layer()->SendDamagedRects();
   layerless_window->SchedulePaintInRect(gfx::Rect(1, 2, 100, 4));
   // Note the the region is clipped by the parent hence 100 going to 11.
   EXPECT_EQ("11,13 11x4",
             gfx::SkIRectToRect(root.layer()->damaged_region().getBounds()).
             ToString());
 
   Window* layerless_window2 = new Window(NULL);  // Owned by |layerless_window|.
-  layerless_window2->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  layerless_window2->Init(WINDOW_LAYER_NONE);
   layerless_window2->SetBounds(gfx::Rect(1, 2, 3, 4));
   layerless_window->AddChild(layerless_window2);
 
   root.layer()->SendDamagedRects();
   layerless_window2->SchedulePaintInRect(gfx::Rect(1, 2, 100, 4));
   // Note the the region is clipped by the |layerless_window| hence 100 going to
   // 2.
   EXPECT_EQ("12,15 2x2",
             gfx::SkIRectToRect(root.layer()->damaged_region().getBounds()).
             ToString());
 }
 
 // Verifies bounds of layerless windows are correctly updated when adding
 // removing.
 TEST_F(WindowTest, NestedLayerlessWindowsBoundsOnAddRemove) {
   // Creates the following structure (all children owned by root):
   // root
   //   w1ll      1,2
   //     w11ll   3,4
   //       w111  5,6
   //     w12     7,8
   //       w121  9,10
   //
   // ll: layer less, eg no layer
   Window root(NULL);
-  root.InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  root.Init(WINDOW_LAYER_NOT_DRAWN);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   Window* w1ll = new Window(NULL);
-  w1ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w1ll->Init(WINDOW_LAYER_NONE);
   w1ll->SetBounds(gfx::Rect(1, 2, 100, 100));
 
   Window* w11ll = new Window(NULL);
-  w11ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w11ll->Init(WINDOW_LAYER_NONE);
   w11ll->SetBounds(gfx::Rect(3, 4, 100, 100));
   w1ll->AddChild(w11ll);
 
   Window* w111 = new Window(NULL);
-  w111->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w111->Init(WINDOW_LAYER_NOT_DRAWN);
   w111->SetBounds(gfx::Rect(5, 6, 100, 100));
   w11ll->AddChild(w111);
 
   Window* w12 = new Window(NULL);
-  w12->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w12->Init(WINDOW_LAYER_NOT_DRAWN);
   w12->SetBounds(gfx::Rect(7, 8, 100, 100));
   w1ll->AddChild(w12);
 
   Window* w121 = new Window(NULL);
-  w121->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w121->Init(WINDOW_LAYER_NOT_DRAWN);
   w121->SetBounds(gfx::Rect(9, 10, 100, 100));
   w12->AddChild(w121);
 
   root.AddChild(w1ll);
 
   // All layers should be parented to the root.
   EXPECT_EQ(root.layer(), w111->layer()->parent());
   EXPECT_EQ(root.layer(), w12->layer()->parent());
   EXPECT_EQ(w12->layer(), w121->layer()->parent());
 
@@ skipping 36 matching lines @@
   // Creates the following structure (all children owned by root):
   // root
   //   w1ll      1,2
   //     w11ll   3,4
   //       w111  5,6
   //     w12     7,8
   //       w121  9,10
   //
   // ll: layer less, eg no layer
   Window root(NULL);
-  root.InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  root.Init(WINDOW_LAYER_NOT_DRAWN);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   Window* w1ll = new Window(NULL);
-  w1ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w1ll->Init(WINDOW_LAYER_NONE);
   w1ll->SetBounds(gfx::Rect(1, 2, 100, 100));
 
   Window* w11ll = new Window(NULL);
-  w11ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w11ll->Init(WINDOW_LAYER_NONE);
   w11ll->SetBounds(gfx::Rect(3, 4, 100, 100));
   w1ll->AddChild(w11ll);
 
   Window* w111 = new Window(NULL);
-  w111->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w111->Init(WINDOW_LAYER_NOT_DRAWN);
   w111->SetBounds(gfx::Rect(5, 6, 100, 100));
   w11ll->AddChild(w111);
 
   Window* w12 = new Window(NULL);
-  w12->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w12->Init(WINDOW_LAYER_NOT_DRAWN);
   w12->SetBounds(gfx::Rect(7, 8, 100, 100));
   w1ll->AddChild(w12);
 
   Window* w121 = new Window(NULL);
-  w121->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w121->Init(WINDOW_LAYER_NOT_DRAWN);
   w121->SetBounds(gfx::Rect(9, 10, 100, 100));
   w12->AddChild(w121);
 
   root.AddChild(w1ll);
 
   w111->SetBounds(gfx::Rect(7, 8, 11, 12));
   EXPECT_EQ("7,8 11x12", w111->bounds().ToString());
   EXPECT_EQ("7,8 11x12", w111->GetTargetBounds().ToString());
   EXPECT_EQ("11,14 11x12", w111->layer()->bounds().ToString());
 
@@ skipping 70 matching lines @@
   //   w1ll      1,2 40x50
   //     w11ll   3,4 11x12
   //       w111  5,6
   //
   // ll: layer less, eg no layer
   PaintWindowDelegate w1ll_delegate;
   PaintWindowDelegate w11ll_delegate;
   PaintWindowDelegate w111_delegate;
 
   Window root(NULL);
-  root.InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  root.Init(WINDOW_LAYER_NOT_DRAWN);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   Window* w1ll = new Window(&w1ll_delegate);
-  w1ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w1ll->Init(WINDOW_LAYER_NONE);
   w1ll->SetBounds(gfx::Rect(1, 2, 40, 50));
   w1ll->Show();
   root.AddChild(w1ll);
 
   Window* w11ll = new Window(&w11ll_delegate);
-  w11ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w11ll->Init(WINDOW_LAYER_NONE);
   w11ll->SetBounds(gfx::Rect(3, 4, 11, 12));
   w11ll->Show();
   w1ll->AddChild(w11ll);
 
   Window* w111 = new Window(&w111_delegate);
-  w111->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w111->Init(WINDOW_LAYER_NOT_DRAWN);
   w111->SetBounds(gfx::Rect(5, 6, 100, 100));
   w111->Show();
   w11ll->AddChild(w111);
 
   EXPECT_EQ(0, w1ll_delegate.paint_count());
   EXPECT_EQ(0, w11ll_delegate.paint_count());
   EXPECT_EQ(0, w111_delegate.paint_count());
 
   // Paint the root, this should trigger painting of the two layerless
   // descendants but not the layered descendant.
@@ skipping 31 matching lines @@
   // Creates the following structure (all children owned by root):
   // root
   //   w1ll      1,2
   //     w11ll   3,4
   //       w111  5,6
   //     w12     7,8
   //       w121  9,10
   //
   // ll: layer less, eg no layer
   Window root(NULL);
-  root.InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  root.Init(WINDOW_LAYER_NOT_DRAWN);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   Window* w1ll = new Window(NULL);
-  w1ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w1ll->Init(WINDOW_LAYER_NONE);
   w1ll->SetBounds(gfx::Rect(1, 2, 100, 100));
 
   Window* w11ll = new Window(NULL);
-  w11ll->InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  w11ll->Init(WINDOW_LAYER_NONE);
   w11ll->SetBounds(gfx::Rect(3, 4, 100, 100));
   w1ll->AddChild(w11ll);
 
   Window* w111 = new Window(NULL);
-  w111->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w111->Init(WINDOW_LAYER_NOT_DRAWN);
   w111->SetBounds(gfx::Rect(5, 6, 100, 100));
   w11ll->AddChild(w111);
 
   Window* w12 = new Window(NULL);
-  w12->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w12->Init(WINDOW_LAYER_NOT_DRAWN);
   w12->SetBounds(gfx::Rect(7, 8, 100, 100));
   w1ll->AddChild(w12);
 
   Window* w121 = new Window(NULL);
-  w121->InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+  w121->Init(WINDOW_LAYER_NOT_DRAWN);
   w121->SetBounds(gfx::Rect(9, 10, 100, 100));
   w12->AddChild(w121);
 
   root.AddChild(w1ll);
 
   // w111->w11ll
   EXPECT_EQ("5,6", ConvertPointToTargetString(w111, w11ll));
 
   // w111->w1ll
   EXPECT_EQ("8,10", ConvertPointToTargetString(w111, w1ll));
@@ skipping 17 matching lines @@
   EXPECT_EQ("4,6", ConvertPointToTargetString(w11ll, &root));
 
   // w11ll->w12
   EXPECT_EQ("-4,-4", ConvertPointToTargetString(w11ll, w12));
 }
 
 #if !defined(NDEBUG)
 // Verifies PrintWindowHierarchy() doesn't crash with a layerless window.
 TEST_F(WindowTest, PrintWindowHierarchyNotCrashLayerless) {
   Window root(NULL);
-  root.InitWithWindowLayerType(WINDOW_LAYER_NONE);
+  root.Init(WINDOW_LAYER_NONE);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   root.PrintWindowHierarchy(0);
 }
 #endif
 
 namespace {
 
 // See AddWindowsFromString() for details.
 aura::Window* CreateWindowFromDescription(const std::string& description,
                                           WindowDelegate* delegate) {
   WindowLayerType window_type = WINDOW_LAYER_NOT_DRAWN;
   std::vector<std::string> tokens;
   Tokenize(description, ":", &tokens);
   DCHECK(!tokens.empty());
   std::string name(tokens[0]);
   tokens.erase(tokens.begin());
   if (!tokens.empty()) {
     if (tokens[0] == "ll") {
       window_type = WINDOW_LAYER_NONE;
       tokens.erase(tokens.begin());
     }
     DCHECK(tokens.empty()) << "unknown tokens for creating window "
                            << description;
   }
   Window* window = new Window(delegate);
-  window->InitWithWindowLayerType(window_type);
+  window->Init(window_type);
   window->SetName(name);
   // Window name is only propagated to layer in debug builds.
   if (window->layer())
     window->layer()->set_name(name);
   return window;
 }
 
 // Creates and adds a tree of windows to |parent|. |description| consists
 // of the following pieces:
 //   X: Identifies a new window. Consists of a name and optionally ":ll" to
@@ skipping 209 matching lines @@
       "1",
       "2",
       STACK_ABOVE,
       "2 [ 21 ] 1 [ 11 12 ]",
       "21 11 12",
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     test::TestWindowDelegate delegate;
     Window root(NULL);
-    root.InitWithWindowLayerType(WINDOW_LAYER_NOT_DRAWN);
+    root.Init(WINDOW_LAYER_NOT_DRAWN);
     root.SetBounds(gfx::Rect(0, 0, 100, 100));
     AddWindowsFromString(
         &root,
         data[i].initial_description,
         static_cast<std::string::size_type>(0), &delegate);
     aura::Window* source = FindWindowByName(&root, data[i].source_window);
     ASSERT_TRUE(source != NULL) << "unable to find source window "
                                 << data[i].source_window << " at " << i;
     aura::Window* target = FindWindowByName(&root, data[i].target_window);
     switch (data[i].stack_type) {
@@ skipping 18 matching lines @@
               BuildRootLayerTreeDescription(*root.layer()))
         << "layer tree doesn't match at " << i;
     EXPECT_EQ(data[i].expected_description,
               BuildRootWindowTreeDescription(root))
         << "window tree doesn't match at " << i;
   }
 }
 
 }  // namespace test
 }  // namespace aura