Eliminate ash::internal namespace

ash/wm/dock/docked_window_layout_manager_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/wm/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 17 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
-namespace internal {
 
 class DockedWindowLayoutManagerTest
     : public test::AshTestBase,
       public testing::WithParamInterface<ui::wm::WindowType> {
  public:
   DockedWindowLayoutManagerTest() : window_type_(GetParam()) {}
   virtual ~DockedWindowLayoutManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
@@ skipping 45 matching lines @@
       PanelLayoutManager* manager =
           static_cast<PanelLayoutManager*>(GetPanelContainer(window)->
               layout_manager());
       manager->Relayout();
     }
     return window;
   }
 
   aura::Window* GetPanelContainer(aura::Window* panel) {
     return Shell::GetContainer(panel->GetRootWindow(),
-                               internal::kShellWindowId_PanelContainer);
+                               kShellWindowId_PanelContainer);
   }
 
   static WindowResizer* CreateSomeWindowResizer(
       aura::Window* window,
       const gfx::Point& point_in_parent,
       int window_component) {
     return CreateWindowResizer(
         window,
         point_in_parent,
         window_component,
@@ skipping 27 matching lines @@
     resizer_->RevertDrag();
     resizer_.reset();
   }
 
   // Panels are parented by panel container during drags.
   // Docked windows are parented by dock container during drags.
   // All other windows that we are testing here have default container as a
   // parent.
   int CorrectContainerIdDuringDrag() {
     if (window_type_ == ui::wm::WINDOW_TYPE_PANEL)
-      return internal::kShellWindowId_PanelContainer;
-    return internal::kShellWindowId_DockedContainer;
+      return kShellWindowId_PanelContainer;
+    return kShellWindowId_DockedContainer;
   }
 
   // Test dragging the window vertically (to detach if it is a panel) and then
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragRelativeToEdge(DockedEdge edge, aura::Window* window, int dx) {
     DragVerticallyAndRelativeToEdge(
         edge,
         window,
         dx,
         window_type_ == ui::wm::WINDOW_TYPE_PANEL ? -100 : 20);
@@ skipping 31 matching lines @@
       dx += work_area.x() - initial_location_in_screen.x();
     else if (edge == DOCKED_EDGE_RIGHT)
       dx += work_area.right() - 1 - initial_location_in_screen.x();
     DragMove(dx, dy);
     EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
     // Release the mouse and the panel should be attached to the dock.
     DragEnd();
 
     // x-coordinate can get adjusted by snapping or sticking.
     // y-coordinate could be changed by possible automatic layout if docked.
-    if (window->parent()->id() != internal::kShellWindowId_DockedContainer &&
+    if (window->parent()->id() != kShellWindowId_DockedContainer &&
         !wm::GetWindowState(window)->HasRestoreBounds()) {
       EXPECT_EQ(initial_bounds.y() + dy, window->GetBoundsInScreen().y());
     }
   }
 
  private:
   scoped_ptr<WindowResizer> resizer_;
   scoped_ptr<test::ShelfViewTestAPI> shelf_view_test_;
   ui::wm::WindowType window_type_;
 
@@ skipping 11 matching lines @@
 
   gfx::Rect bounds(0, 0, 201, 201);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and docked at the right edge.
   // Its width should shrink or grow to ideal width.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(ideal_width(), window->bounds().width());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Tests that with a window docked on the left the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingLeft) {
   if (!SupportsHostWindowResize())
     return;
 
   gfx::Rect bounds(0, 0, 201, 201);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->bounds().x(),
             window->GetBoundsInScreen().x());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager = static_cast<DockedWindowLayoutManager*>(
       window->parent()->layout_manager());
 
   // Create two additional windows and test their auto-placement
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
   gfx::Rect desktop_area = window1->parent()->bounds();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
   window1->Hide();
   window1->SetBounds(gfx::Rect(250, 32, 231, 320));
@@ skipping 29 matching lines @@
   if (!SupportsHostWindowResize())
     return;
 
   gfx::Rect bounds(0, 0, 201, 201);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager = static_cast<DockedWindowLayoutManager*>(
       window->parent()->layout_manager());
 
   // Create two additional windows and test their auto-placement
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
   gfx::Rect desktop_area = window1->parent()->bounds();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 231, 320));
@@ skipping 33 matching lines @@
   UpdateDisplay("600x600,600x600");
 
   gfx::Rect bounds(600, 0, 201, 201);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
   // Drag pointer to the right edge of the second screen.
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager = static_cast<DockedWindowLayoutManager*>(
       window->parent()->layout_manager());
 
   // Create two additional windows and test their auto-placement
   bounds = gfx::Rect(616, 32, 231, 320);
   scoped_ptr<aura::Window> window1(
       CreateTestWindowInShellWithDelegate(NULL, 1, bounds));
   gfx::Rect desktop_area = window1->parent()->bounds();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
@@ skipping 30 matching lines @@
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
 
   // The windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Test that the gaps differ at most by a single pixel.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   int gap1 = w1->GetBoundsInScreen().y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = work_area.bottom() - w2->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_EQ(0, gap3);
 }
 
 // Adds two non-overlapping windows and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsDragging) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
 
   // The windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Drag w2 above w1.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(w2.get(), 0, 20));
   DragMove(0, -w2->bounds().height() / 2 - min_dock_gap() - 1);
   DragEnd();
 
   // Test the new windows order and that the gaps differ at most by a pixel.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   int gap1 = w2->GetBoundsInScreen().y() - work_area.y();
@@ skipping 13 matching lines @@
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 500);
   scoped_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 600);
 
   // All windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(w3->GetRootWindow()->bounds().right(),
             w3->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w3->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
   // Test that the top and bottom windows are clamped in work area and
   // that the gaps between the windows differ at most by a pixel.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   int gap1 = w1->GetBoundsInScreen().y() - work_area.y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = w3->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap4 = work_area.bottom() - w3->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
@@ skipping 42 matching lines @@
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 1000, 201, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 1000 + 20);
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 1000, 210, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 1000 + 500);
   scoped_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 1000, 220, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 1000 + 600);
 
   // All windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(w3->GetRootWindow()->bounds().right(),
             w3->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w3->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   // Test that the top and bottom windows are clamped in work area and
   // that the overlaps between the windows differ at most by a pixel.
   int gap1 = w1->GetBoundsInScreen().y() - work_area.y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = w3->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap4 = work_area.bottom() - w3->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
@@ skipping 118 matching lines @@
   // Secondary drag ensures that we are testing the minimum size restriction
   // and not just failure to get past the tiling step in SnapSizer.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window.get(),
                                                             25, 5));
   DragMove(150,0);
   DragEnd();
 
   // The window should not get docked even though it is dragged past the edge.
   EXPECT_NE(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
-  EXPECT_NE(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_NE(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Docks three windows and tests that the very first window gets minimized.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsMinimize) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 200);
   scoped_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 204)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 300);
 
   // The last two windows should be attached and snapped to the right edge.
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(w3->GetRootWindow()->bounds().right(),
             w3->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w3->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
   // The first window should get minimized but parented by the dock container.
   EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMinimized());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsNormalStateType());
   EXPECT_TRUE(wm::GetWindowState(w3.get())->IsNormalStateType());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 }
 
 // Docks up to three windows and tests that they split vertical space.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsSplitHeightEvenly) {
   if (!SupportsHostWindowResize())
     return;
 
   UpdateDisplay("600x1000");
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 200);
 
   // The two windows should be attached and snapped to the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // The two windows should be same size vertically and almost 1/2 of work area.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   EXPECT_NEAR(w1->GetBoundsInScreen().height(),
               w2->GetBoundsInScreen().height(),
               1);
   EXPECT_NEAR(work_area.height() / 2, w1->GetBoundsInScreen().height(),
               min_dock_gap() * 2);
 
   // Create and dock the third window.
   scoped_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 204)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 300);
 
   // All three windows should be docked and snapped to the right edge.
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w3->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
   // All windows should be near same size vertically and about 1/3 of work area.
   EXPECT_NEAR(w1->GetBoundsInScreen().height(),
               w2->GetBoundsInScreen().height(),
               1);
   EXPECT_NEAR(w2->GetBoundsInScreen().height(),
               w3->GetBoundsInScreen().height(),
               1);
   EXPECT_NEAR(work_area.height() / 3, w1->GetBoundsInScreen().height(),
               min_dock_gap() * 2);
@@ skipping 15 matching lines @@
   delegate2.set_maximum_size(gfx::Size(0, 100));
   scoped_ptr<aura::Window> w2(CreateTestWindowWithDelegate(
       gfx::Rect(0, 0, 280, 90), &delegate2));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 200);
 
   // The two windows should be attached and snapped to the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // The two windows should have their heights restricted.
   EXPECT_EQ(300, w1->GetBoundsInScreen().height());
   EXPECT_EQ(100, w2->GetBoundsInScreen().height());
 
   // w1 should be more than half of the work area height (even with a margin).
   // w2 should be less than half of the work area height (even with a margin).
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   EXPECT_GT(w1->GetBoundsInScreen().height(), work_area.height() / 2 + 10);
@@ skipping 14 matching lines @@
   // Drag pointer to the right edge of the second screen.
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // Simulate disconnection of the secondary display.
   UpdateDisplay("600x700");
 
   // The window should be still docked at the right edge.
   // Its height should grow to match the new work area.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
   EXPECT_EQ(ideal_width(), window->bounds().width());
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(window.get()).work_area();
   EXPECT_EQ(work_area.height(), window->GetBoundsInScreen().height());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowLayoutManagerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
-}  // namespace internal
+
 }  // namespace ash