Move wm/core to wm namespace.

ash/wm/window_animations.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/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 51 matching lines @@
 const float kLayerScaleAboveSize = 1.1f;
 const float kLayerScaleBelowSize = .9f;
 
 int64 Round64(float f) {
   return static_cast<int64>(f + 0.5f);
 }
 
 base::TimeDelta GetCrossFadeDuration(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) {
-  if (views::corewm::WindowAnimationsDisabled(window))
+  if (::wm::WindowAnimationsDisabled(window))
     return base::TimeDelta();
 
   int old_area = old_bounds.width() * old_bounds.height();
   int new_area = new_bounds.width() * new_bounds.height();
   int max_area = std::max(old_area, new_area);
   // Avoid divide by zero.
   if (max_area == 0)
     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
 
   int delta_area = std::abs(old_area - new_area);
@@ skipping 75 matching lines @@
   window->layer()->set_delegate(window);
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kLayerAnimationsForMinimizeDurationMS);
   settings.SetTransitionDuration(duration);
   AddLayerAnimationsForMinimize(window, true);
 
   // Now that the window has been restored, we need to clear its animation style
   // to default so that normal animation applies.
-  views::corewm::SetWindowVisibilityAnimationType(
-      window, views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
+  ::wm::SetWindowVisibilityAnimationType(
+      window, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 }
 
 void AnimateHideWindow_Minimize(aura::Window* window) {
   window->layer()->set_delegate(NULL);
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kLayerAnimationsForMinimizeDurationMS);
   settings.SetTransitionDuration(duration);
   settings.AddObserver(
-      views::corewm::CreateHidingWindowAnimationObserver(window));
+      ::wm::CreateHidingWindowAnimationObserver(window));
   window->layer()->SetVisible(false);
 
   AddLayerAnimationsForMinimize(window, false);
 }
 
 void AnimateShowHideWindowCommon_BrightnessGrayscale(aura::Window* window,
                                                      bool show) {
   window->layer()->set_delegate(window);
 
   float start_value, end_value;
@@ skipping 12 matching lines @@
     window->layer()->SetVisible(true);
   }
 
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs);
 
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.SetTransitionDuration(duration);
   if (!show) {
     settings.AddObserver(
-        views::corewm::CreateHidingWindowAnimationObserver(window));
+        ::wm::CreateHidingWindowAnimationObserver(window));
   }
 
   window->layer()->GetAnimator()->
       ScheduleTogether(
           CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
   if (!show) {
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
     window->layer()->SetVisible(false);
   }
 }
 
 void AnimateShowWindow_BrightnessGrayscale(aura::Window* window) {
   AnimateShowHideWindowCommon_BrightnessGrayscale(window, true);
 }
 
 void AnimateHideWindow_BrightnessGrayscale(aura::Window* window) {
   AnimateShowHideWindowCommon_BrightnessGrayscale(window, false);
 }
 
 bool AnimateShowWindow(aura::Window* window) {
-  if (!views::corewm::HasWindowVisibilityAnimationTransition(
-          window, views::corewm::ANIMATE_SHOW)) {
+  if (!::wm::HasWindowVisibilityAnimationTransition(
+          window, ::wm::ANIMATE_SHOW)) {
     return false;
   }
 
-  switch (views::corewm::GetWindowVisibilityAnimationType(window)) {
+  switch (::wm::GetWindowVisibilityAnimationType(window)) {
     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateShowWindow_Minimize(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
       AnimateShowWindow_BrightnessGrayscale(window);
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool AnimateHideWindow(aura::Window* window) {
-  if (!views::corewm::HasWindowVisibilityAnimationTransition(
-          window, views::corewm::ANIMATE_HIDE)) {
+  if (!::wm::HasWindowVisibilityAnimationTransition(
+          window, ::wm::ANIMATE_HIDE)) {
     return false;
   }
 
-  switch (views::corewm::GetWindowVisibilityAnimationType(window)) {
+  switch (::wm::GetWindowVisibilityAnimationType(window)) {
     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateHideWindow_Minimize(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
       AnimateHideWindow_BrightnessGrayscale(window);
       return true;
     default:
       NOTREACHED();
       return false;
   }
@@ skipping 124 matching lines @@
     window->layer()->SetTransform(gfx::Transform());
     if (!old_on_top) {
       // New layer is on top, fade it in.
       window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
     }
   }
   return duration;
 }
 
 bool AnimateOnChildWindowVisibilityChanged(aura::Window* window, bool visible) {
-  if (views::corewm::WindowAnimationsDisabled(window))
+  if (::wm::WindowAnimationsDisabled(window))
     return false;
 
   // Attempt to run CoreWm supplied animation types.
-  if (views::corewm::AnimateOnChildWindowVisibilityChanged(window, visible))
+  if (::wm::AnimateOnChildWindowVisibilityChanged(window, visible))
     return true;
 
   // Otherwise try to run an Ash-specific animation.
   if (visible)
     return AnimateShowWindow(window);
   // Don't start hiding the window again if it's already being hidden.
   return window->layer()->GetTargetOpacity() != 0.0f &&
       AnimateHideWindow(window);
 }
 
@@ skipping 79 matching lines @@
   }
 
   // Assume the shelf is overflowed, zoom off to the bottom right of the
   // work area.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
   return gfx::Rect(work_area.right(), work_area.bottom(), 0, 0);
 }
 
 }  // namespace ash