Eliminate ash::internal namespace

ash/wm/ash_focus_rules.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/ash_focus_rules.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_state.h"
 #include "ui/aura/window.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 // These are the list of container ids of containers which may contain windows
 // that need to be activated in the order that they should be activated.
 const int kWindowContainerIds[] = {
-    internal::kShellWindowId_OverlayContainer,
-    internal::kShellWindowId_LockSystemModalContainer,
-    internal::kShellWindowId_SettingBubbleContainer,
-    internal::kShellWindowId_LockScreenContainer,
-    internal::kShellWindowId_SystemModalContainer,
-    internal::kShellWindowId_AlwaysOnTopContainer,
-    internal::kShellWindowId_AppListContainer,
-    internal::kShellWindowId_DefaultContainer,
+    kShellWindowId_OverlayContainer,
+    kShellWindowId_LockSystemModalContainer,
+    kShellWindowId_SettingBubbleContainer,
+    kShellWindowId_LockScreenContainer,
+    kShellWindowId_SystemModalContainer,
+    kShellWindowId_AlwaysOnTopContainer,
+    kShellWindowId_AppListContainer,
+    kShellWindowId_DefaultContainer,
 
     // Docked, panel, launcher and status are intentionally checked after other
     // containers even though these layers are higher. The user expects their
     // windows to be focused before these elements.
-    internal::kShellWindowId_DockedContainer,
-    internal::kShellWindowId_PanelContainer,
-    internal::kShellWindowId_ShelfContainer,
-    internal::kShellWindowId_StatusContainer,
-};
+    kShellWindowId_DockedContainer,
+    kShellWindowId_PanelContainer,
+    kShellWindowId_ShelfContainer,
+    kShellWindowId_StatusContainer, };
 
 bool BelongsToContainerWithEqualOrGreaterId(const aura::Window* window,
                                             int container_id) {
   for (; window; window = window->parent()) {
     if (window->id() >= container_id)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // AshFocusRules, public:
 
 AshFocusRules::AshFocusRules() {
 }
 
 AshFocusRules::~AshFocusRules() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AshFocusRules, ::wm::FocusRules:
 
 bool AshFocusRules::SupportsChildActivation(aura::Window* window) const {
-  if (window->id() == internal::kShellWindowId_DefaultContainer)
+  if (window->id() == kShellWindowId_DefaultContainer)
     return true;
 
   for (size_t i = 0; i < arraysize(kWindowContainerIds); i++) {
     if (window->id() == kWindowContainerIds[i])
       return true;
   }
   return false;
 }
 
 bool AshFocusRules::IsWindowConsideredVisibleForActivation(
     aura::Window* window) const {
   if (BaseFocusRules::IsWindowConsideredVisibleForActivation(window))
     return true;
 
   // Minimized windows are hidden in their minimized state, but they can always
   // be activated.
   if (wm::GetWindowState(window)->IsMinimized())
     return true;
 
-  return window->TargetVisibility() && (window->parent()->id() ==
-      internal::kShellWindowId_DefaultContainer || window->parent()->id() ==
-      internal::kShellWindowId_LockScreenContainer);
+  return window->TargetVisibility() &&
+         (window->parent()->id() == kShellWindowId_DefaultContainer ||
+          window->parent()->id() == kShellWindowId_LockScreenContainer);
 }
 
 bool AshFocusRules::CanActivateWindow(aura::Window* window) const {
   // Clearing activation is always permissible.
   if (!window)
     return true;
 
   if (!BaseFocusRules::CanActivateWindow(window))
     return false;
 
   if (Shell::GetInstance()->IsSystemModalWindowOpen()) {
     return BelongsToContainerWithEqualOrGreaterId(
-          window, internal::kShellWindowId_SystemModalContainer);
+        window, kShellWindowId_SystemModalContainer);
   }
 
   return true;
 }
 
 aura::Window* AshFocusRules::GetNextActivatableWindow(
     aura::Window* ignore) const {
   DCHECK(ignore);
 
   int starting_container_index = 0;
@@ skipping 52 matching lines @@
     if (*i != ignore &&
         window_state->CanActivate() &&
         !window_state->IsMinimized())
       return *i;
   }
   return NULL;
 }
 
 }  // namespace wm
 }  // namespace ash