Rename the aura_shell namespace to ash

ash/accelerators/accelerator_controller_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/aura_shell_test_base.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/base/x/x11_util.h"
 #endif
 
-namespace aura_shell {
+namespace ash {
 namespace test {
 
 namespace {
 class TestTarget : public ui::AcceleratorTarget {
  public:
   TestTarget() : accelerator_pressed_count_(0) {};
   virtual ~TestTarget() {};
 
   int accelerator_pressed_count() const {
     return accelerator_pressed_count_;
@@ skipping 105 matching lines @@
 
   // The non-registered accelerator is not processed.
   const ui::Accelerator accelerator_b(ui::VKEY_B, false, false, false);
   EXPECT_FALSE(GetController()->Process(accelerator_b));
 }
 
 #if defined(OS_WIN) || defined(USE_X11)
 TEST_F(AcceleratorControllerTest, ProcessOnce) {
   // A focused window must exist for accelerators to be processed.
   aura::Window* default_container =
-      aura_shell::Shell::GetInstance()->GetContainer(
+      ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_DefaultContainer);
   aura::Window* window = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
       default_container);
   ActivateWindow(window);
 
   const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
   TestTarget target;
@@ skipping 21 matching lines @@
   EXPECT_TRUE(aura::RootWindow::GetInstance()->GetDispatcher()->Dispatch(
       &key_event));
 #endif
   EXPECT_EQ(1, target.accelerator_pressed_count());
 }
 #endif
 
 TEST_F(AcceleratorControllerTest, GlobalAccelerators) {
   // A focused window must exist for accelerators to be processed.
   aura::Window* default_container =
-      aura_shell::Shell::GetInstance()->GetContainer(
+      ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_DefaultContainer);
   aura::Window* window = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
       default_container);
   ActivateWindow(window);
 
   // CycleBackward
   EXPECT_TRUE(GetController()->Process(
@@ skipping 15 matching lines @@
 #if !defined(OS_LINUX)
   // ToggleDesktopFullScreen (not implemented yet on Linux)
   EXPECT_TRUE(GetController()->Process(
       ui::Accelerator(ui::VKEY_F11, false, true, false)));
 #endif
 #endif
 }
 
 TEST_F(AcceleratorControllerTest, HandleCycleWindow) {
   aura::Window* default_container =
-      aura_shell::Shell::GetInstance()->GetContainer(
+      ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_DefaultContainer);
   aura::Window* window0 = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
       default_container);
   aura::Window* window1 = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
@@ skipping 16 matching lines @@
 
   ui::Accelerator cycle_backward(ui::VKEY_TAB, true, false, true);
   EXPECT_TRUE(GetController()->Process(cycle_backward));
   EXPECT_TRUE(IsActiveWindow(window2));
   EXPECT_TRUE(GetController()->Process(cycle_backward));
   EXPECT_TRUE(IsActiveWindow(window1));
   EXPECT_TRUE(GetController()->Process(cycle_backward));
   EXPECT_TRUE(IsActiveWindow(window0));
 
   aura::Window* modal_container =
-      aura_shell::Shell::GetInstance()->GetContainer(
+      ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_AlwaysOnTopContainer);
   aura::Window* modal_window = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
       modal_container);
 
   // When the modal window is active, cycling window does not take effect.
   ActivateWindow(modal_window);
   EXPECT_TRUE(IsActiveWindow(modal_window));
@@ skipping 18 matching lines @@
   EXPECT_FALSE(IsActiveWindow(modal_window));
   EXPECT_TRUE(GetController()->Process(cycle_backward));
   EXPECT_FALSE(IsActiveWindow(modal_window));
   EXPECT_TRUE(GetController()->Process(cycle_backward));
   EXPECT_FALSE(IsActiveWindow(modal_window));
   EXPECT_TRUE(GetController()->Process(cycle_backward));
   EXPECT_FALSE(IsActiveWindow(modal_window));
 
   // When a screen lock window is visible, cycling window does not take effect.
   aura::Window* lock_screen_container =
-      aura_shell::Shell::GetInstance()->GetContainer(
+      ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_LockScreenContainer);
   aura::Window* lock_screen_window = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
       lock_screen_container);
 
   lock_screen_window->Show();
   EXPECT_FALSE(GetController()->Process(cycle_forward));
   EXPECT_FALSE(GetController()->Process(cycle_backward));
 
   // When a screen lock window is visible, cycling window does not take effect.
   // But otherwise, cycling window does take effect.
   aura::Window* lock_modal_container =
-      aura_shell::Shell::GetInstance()->GetContainer(
+      ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_LockModalContainer);
   aura::Window* lock_modal_window = aura::test::CreateTestWindowWithDelegate(
       new aura::test::TestWindowDelegate,
       -1,
       gfx::Rect(),
       lock_modal_container);
 
   lock_modal_window->Show();
   EXPECT_FALSE(GetController()->Process(cycle_forward));
   EXPECT_FALSE(GetController()->Process(cycle_backward));
   lock_screen_window->Hide();
   EXPECT_TRUE(GetController()->Process(cycle_forward));
   EXPECT_TRUE(GetController()->Process(cycle_backward));
 }
 
 }  // namespace test
-}  // namespace aura_shell
+}  // namespace ash