Eliminate ash::internal namespace

ash/wm/system_modal_container_layout_manager_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 "ash/wm/system_modal_container_layout_manager.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 11 matching lines @@
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace test {
 
 namespace {
 
 aura::Window* GetModalContainer() {
   return Shell::GetPrimaryRootWindowController()->GetContainer(
-      ash::internal::kShellWindowId_SystemModalContainer);
+      ash::kShellWindowId_SystemModalContainer);
 }
 
 bool AllRootWindowsHaveModalBackgroundsForContainer(int container_id) {
   std::vector<aura::Window*> containers =
       Shell::GetContainersFromAllRootWindows(container_id, NULL);
   bool has_modal_screen = !containers.empty();
   for (std::vector<aura::Window*>::iterator iter = containers.begin();
        iter != containers.end(); ++iter) {
-    has_modal_screen &=
-        static_cast<internal::SystemModalContainerLayoutManager*>(
-            (*iter)->layout_manager())->has_modal_background();
+    has_modal_screen &= static_cast<SystemModalContainerLayoutManager*>(
+                            (*iter)->layout_manager())->has_modal_background();
   }
   return has_modal_screen;
 }
 
 bool AllRootWindowsHaveLockedModalBackgrounds() {
   return AllRootWindowsHaveModalBackgroundsForContainer(
-      internal::kShellWindowId_LockSystemModalContainer);
+      kShellWindowId_LockSystemModalContainer);
 }
 
 bool AllRootWindowsHaveModalBackgrounds() {
   return AllRootWindowsHaveModalBackgroundsForContainer(
-      internal::kShellWindowId_SystemModalContainer);
+      kShellWindowId_SystemModalContainer);
 }
 
 class TestWindow : public views::WidgetDelegateView {
  public:
   explicit TestWindow(bool modal) : modal_(modal) {}
   virtual ~TestWindow() {}
 
   // The window needs be closed from widget in order for
   // aura::client::kModalKey property to be reset.
   static void CloseTestWindow(aura::Window* window) {
@@ skipping 240 matching lines @@
 
   for (int block_reason = FIRST_BLOCK_REASON;
        block_reason < NUMBER_OF_BLOCK_REASONS;
        ++block_reason) {
     // Create a window in the lock screen container and ensure that it receives
     // the mouse event instead of the modal window (crbug.com/110920).
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     EventTestWindow* lock_delegate = new EventTestWindow(false);
     scoped_ptr<aura::Window> lock(lock_delegate->OpenTestWindowWithParent(
         Shell::GetPrimaryRootWindowController()->GetContainer(
-            ash::internal::kShellWindowId_LockScreenContainer)));
+            ash::kShellWindowId_LockScreenContainer)));
     EXPECT_TRUE(wm::IsActiveWindow(lock.get()));
     e1.ClickLeftButton();
     EXPECT_EQ(1, lock_delegate->mouse_presses());
 
     // Make sure that a modal container created by the lock screen can still
     // receive mouse events.
     EventTestWindow* lock_modal_delegate = new EventTestWindow(true);
     aura::Window* lock_modal =
         lock_modal_delegate->OpenTestWindowWithParent(lock.get());
     EXPECT_TRUE(wm::IsActiveWindow(lock_modal));
     e1.ClickLeftButton();
     // Verify that none of the other containers received any more mouse presses.
     EXPECT_EQ(1, lock_modal_delegate->mouse_presses());
     EXPECT_EQ(1, lock_delegate->mouse_presses());
     EXPECT_EQ(1, main_delegate->mouse_presses());
     EXPECT_EQ(1, transient_delegate->mouse_presses());
     UnblockUserSession();
   }
 }
 
 // Makes sure we don't crash if a modal window is shown while the parent window
 // is hidden.
 TEST_F(SystemModalContainerLayoutManagerTest, ShowModalWhileHidden) {
   // Hide the lock screen.
-  Shell::GetPrimaryRootWindowController()->GetContainer(
-      internal::kShellWindowId_SystemModalContainer)->layer()->SetOpacity(0);
+  Shell::GetPrimaryRootWindowController()
+      ->GetContainer(kShellWindowId_SystemModalContainer)
+      ->layer()
+      ->SetOpacity(0);
 
   // Create a modal window.
   scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
   scoped_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(parent.get(), true));
   parent->Show();
   modal_window->Show();
 }
 
 // Verifies we generate a capture lost when showing a modal window.
@@ skipping 49 matching lines @@
   EXPECT_FALSE(AllRootWindowsHaveLockedModalBackgrounds());
 
   for (int block_reason = FIRST_BLOCK_REASON;
        block_reason < NUMBER_OF_BLOCK_REASONS;
        ++block_reason) {
     // Normal system modal window while blocked.  Shows blocked system modal
     // background.
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     scoped_ptr<aura::Window> lock_parent(OpenTestWindowWithParent(
         Shell::GetPrimaryRootWindowController()->GetContainer(
-            ash::internal::kShellWindowId_LockScreenContainer),
+            ash::kShellWindowId_LockScreenContainer),
         false));
     scoped_ptr<aura::Window> lock_modal_window(OpenTestWindowWithParent(
         lock_parent.get(), true));
     lock_parent->Show();
     lock_modal_window->Show();
     EXPECT_FALSE(AllRootWindowsHaveModalBackgrounds());
     EXPECT_TRUE(AllRootWindowsHaveLockedModalBackgrounds());
     TestWindow::CloseTestWindow(lock_modal_window.release());
 
     // Normal system modal window while blocked, but it belongs to the normal
@@ skipping 17 matching lines @@
     return;
 
   UpdateDisplay("500x500,500x500");
 
   scoped_ptr<aura::Window> normal(OpenToplevelTestWindow(false));
   normal->SetBounds(gfx::Rect(100, 100, 50, 50));
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(2U, root_windows.size());
   aura::Window* container1 = Shell::GetContainer(
-      root_windows[0], ash::internal::kShellWindowId_SystemModalContainer);
+      root_windows[0], ash::kShellWindowId_SystemModalContainer);
   aura::Window* container2 = Shell::GetContainer(
-      root_windows[1], ash::internal::kShellWindowId_SystemModalContainer);
+      root_windows[1], ash::kShellWindowId_SystemModalContainer);
 
   scoped_ptr<aura::Window> modal1(
       OpenTestWindowWithParent(container1, true));
   EXPECT_TRUE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_TRUE(wm::IsActiveWindow(modal1.get()));
 
   scoped_ptr<aura::Window> modal11(
       OpenTestWindowWithParent(container1, true));
   EXPECT_TRUE(wm::IsActiveWindow(modal11.get()));
 
@@ skipping 24 matching lines @@
 
   // No more modal screen.
   modal1->Hide();
   TestWindow::CloseTestWindow(modal1.release());
   EXPECT_FALSE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_TRUE(wm::IsActiveWindow(normal.get()));
 }
 
 }  // namespace test
 }  // namespace ash