Move wm/core to wm namespace.

ash/root_window_controller.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/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/ash_constants.h"
@@ skipping 48 matching lines @@
 #include "ui/base/hit_test.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/view_model.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/wm/core/capture_controller.h"
+#include "ui/wm/core/easy_resize_window_targeter.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_util.h"
-#include "ui/wm/public/easy_resize_window_targeter.h"
 #include "ui/wm/public/window_types.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/wm/boot_splash_screen_chromeos.h"
 #endif
 
 namespace ash {
 namespace {
 
 #if defined(OS_CHROMEOS)
@@ skipping 511 matching lines @@
            (*iter)->type() == ui::wm::WINDOW_TYPE_PANEL) &&
           (*iter)->layer()->GetTargetVisibility()) {
         topmost_window = *iter;
         break;
       }
     }
   }
   while (topmost_window) {
     if (wm::GetWindowState(topmost_window)->IsFullscreen())
       return topmost_window;
-    topmost_window = views::corewm::GetTransientParent(topmost_window);
+    topmost_window = ::wm::GetTransientParent(topmost_window);
   }
   return NULL;
 }
 
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
@@ skipping 47 matching lines @@
       root_window_layout_(NULL),
       docked_layout_manager_(NULL),
       panel_layout_manager_(NULL),
       touch_hud_debug_(NULL),
       touch_hud_projection_(NULL) {
   GetRootWindowSettings(root_window())->controller = this;
   screen_dimmer_.reset(new ScreenDimmer(root_window()));
 
   stacking_controller_.reset(new StackingController);
   aura::client::SetWindowTreeClient(root_window(), stacking_controller_.get());
-  capture_client_.reset(
-      new views::corewm::ScopedCaptureClient(root_window()));
+  capture_client_.reset(new ::wm::ScopedCaptureClient(root_window()));
 }
 
 void RootWindowController::Init(RootWindowType root_window_type,
                                 bool first_run_after_boot) {
   Shell* shell = Shell::GetInstance();
   shell->InitRootWindow(root_window());
 
   host_->SetCursor(ui::kCursorPointer);
   CreateContainersInRootWindow(root_window());
 
@@ skipping 127 matching lines @@
 
   // The desktop background container is not part of the lock animation, so it
   // is not included in those animate groups.
   // When screen is locked desktop background is moved to lock screen background
   // container (moved back on unlock). We want to make sure that there's an
   // opaque layer occluding the non-lock-screen layers.
   aura::Window* desktop_background_container = CreateContainer(
       kShellWindowId_DesktopBackgroundContainer,
       "DesktopBackgroundContainer",
       root_window);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(
-      desktop_background_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(desktop_background_container);
 
   aura::Window* non_lock_screen_containers = CreateContainer(
       kShellWindowId_NonLockScreenContainersContainer,
       "NonLockScreenContainersContainer",
       root_window);
 
   aura::Window* lock_background_containers = CreateContainer(
       kShellWindowId_LockScreenBackgroundContainer,
       "LockScreenBackgroundContainer",
       root_window);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(
-      lock_background_containers);
+  ::wm::SetChildWindowVisibilityChangesAnimated(lock_background_containers);
 
   aura::Window* lock_screen_containers = CreateContainer(
       kShellWindowId_LockScreenContainersContainer,
       "LockScreenContainersContainer",
       root_window);
   aura::Window* lock_screen_related_containers = CreateContainer(
       kShellWindowId_LockScreenRelatedContainersContainer,
       "LockScreenRelatedContainersContainer",
       root_window);
 
   CreateContainer(kShellWindowId_UnparentedControlContainer,
                   "UnparentedControlContainer",
                   non_lock_screen_containers);
 
   aura::Window* default_container = CreateContainer(
       kShellWindowId_DefaultContainer,
       "DefaultContainer",
       non_lock_screen_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(default_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(default_container);
   SetUsesScreenCoordinates(default_container);
   SetUsesEasyResizeTargeter(default_container);
 
   aura::Window* always_on_top_container = CreateContainer(
       kShellWindowId_AlwaysOnTopContainer,
       "AlwaysOnTopContainer",
       non_lock_screen_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(
-      always_on_top_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(always_on_top_container);
   SetUsesScreenCoordinates(always_on_top_container);
 
   aura::Window* docked_container = CreateContainer(
       kShellWindowId_DockedContainer,
       "DockedContainer",
       non_lock_screen_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(docked_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(docked_container);
   SetUsesScreenCoordinates(docked_container);
   SetUsesEasyResizeTargeter(docked_container);
 
   aura::Window* shelf_container =
       CreateContainer(kShellWindowId_ShelfContainer,
                       "ShelfContainer",
                       non_lock_screen_containers);
   SetUsesScreenCoordinates(shelf_container);
   DescendantShouldStayInSameRootWindow(shelf_container);
 
@@ skipping 16 matching lines @@
                       "AppListContainer",
                       non_lock_screen_containers);
   SetUsesScreenCoordinates(app_list_container);
 
   aura::Window* modal_container = CreateContainer(
       kShellWindowId_SystemModalContainer,
       "SystemModalContainer",
       non_lock_screen_containers);
   modal_container->SetLayoutManager(
       new SystemModalContainerLayoutManager(modal_container));
-  views::corewm::SetChildWindowVisibilityChangesAnimated(modal_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(modal_container);
   SetUsesScreenCoordinates(modal_container);
   SetUsesEasyResizeTargeter(modal_container);
 
   aura::Window* input_method_container = CreateContainer(
       kShellWindowId_InputMethodContainer,
       "InputMethodContainer",
       non_lock_screen_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(
-      input_method_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(input_method_container);
   SetUsesScreenCoordinates(input_method_container);
 
   // TODO(beng): Figure out if we can make this use
   // SystemModalContainerEventFilter instead of stops_event_propagation.
   aura::Window* lock_container = CreateContainer(
       kShellWindowId_LockScreenContainer,
       "LockScreenContainer",
       lock_screen_containers);
   lock_container->SetLayoutManager(
       new internal::WorkspaceLayoutManager(lock_container));
   SetUsesScreenCoordinates(lock_container);
   // TODO(beng): stopsevents
 
   aura::Window* lock_modal_container = CreateContainer(
       kShellWindowId_LockSystemModalContainer,
       "LockSystemModalContainer",
       lock_screen_containers);
   lock_modal_container->SetLayoutManager(
       new SystemModalContainerLayoutManager(lock_modal_container));
-  views::corewm::SetChildWindowVisibilityChangesAnimated(lock_modal_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(lock_modal_container);
   SetUsesScreenCoordinates(lock_modal_container);
   SetUsesEasyResizeTargeter(lock_modal_container);
 
   aura::Window* status_container =
       CreateContainer(kShellWindowId_StatusContainer,
                       "StatusContainer",
                       lock_screen_related_containers);
   SetUsesScreenCoordinates(status_container);
   DescendantShouldStayInSameRootWindow(status_container);
 
   aura::Window* settings_bubble_container = CreateContainer(
       kShellWindowId_SettingBubbleContainer,
       "SettingBubbleContainer",
       lock_screen_related_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(
-      settings_bubble_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(settings_bubble_container);
   SetUsesScreenCoordinates(settings_bubble_container);
   DescendantShouldStayInSameRootWindow(settings_bubble_container);
 
   aura::Window* menu_container = CreateContainer(
       kShellWindowId_MenuContainer,
       "MenuContainer",
       lock_screen_related_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(menu_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(menu_container);
   SetUsesScreenCoordinates(menu_container);
 
   aura::Window* drag_drop_container = CreateContainer(
       kShellWindowId_DragImageAndTooltipContainer,
       "DragImageAndTooltipContainer",
       lock_screen_related_containers);
-  views::corewm::SetChildWindowVisibilityChangesAnimated(drag_drop_container);
+  ::wm::SetChildWindowVisibilityChangesAnimated(drag_drop_container);
   SetUsesScreenCoordinates(drag_drop_container);
 
   aura::Window* overlay_container = CreateContainer(
       kShellWindowId_OverlayContainer,
       "OverlayContainer",
       lock_screen_related_containers);
   SetUsesScreenCoordinates(overlay_container);
 
   aura::Window* virtual_keyboard_parent_container = CreateContainer(
       kShellWindowId_VirtualKeyboardParentContainer,
@@ skipping 36 matching lines @@
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(
     const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : NULL;
 }
 
 }  // namespace internal
 }  // namespace ash