Shuffles and renames ash/common/wm classes

ash/wm/overview/scoped_transform_overview_window.cc

 // Copyright 2013 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/overview/scoped_transform_overview_window.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/wm/window_state.h"
-#include "ash/common/wm/wm_window.h"
+#include "ash/common/wm_window.h"
 #include "ash/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/wm/overview/scoped_overview_animation_settings_factory.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "base/macros.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/transform_util.h"
 
-using WmWindows = std::vector<ash::wm::WmWindow*>;
+using WmWindows = std::vector<ash::WmWindow*>;
 
 namespace ash {
 
 namespace {
 
 // The opacity level that windows will be set to when they are restored.
 const float kRestoreWindowOpacity = 1.0f;
 
-wm::WmWindow* GetTransientRoot(wm::WmWindow* window) {
+WmWindow* GetTransientRoot(WmWindow* window) {
   while (window->GetTransientParent())
     window = window->GetTransientParent();
   return window;
 }
 
 std::unique_ptr<ScopedOverviewAnimationSettings>
 CreateScopedOverviewAnimationSettings(OverviewAnimationType animation_type,
-                                      wm::WmWindow* window) {
+                                      WmWindow* window) {
   return ScopedOverviewAnimationSettingsFactory::Get()
       ->CreateOverviewAnimationSettings(animation_type, window);
 }
 
-// An iterator class that traverses a wm::WmWindow and all of its transient
+// An iterator class that traverses a WmWindow and all of its transient
 // descendants.
 class TransientDescendantIterator {
  public:
   // Creates an empty iterator.
   TransientDescendantIterator();
 
   // Copy constructor required for iterator purposes.
   TransientDescendantIterator(
       const TransientDescendantIterator& other) = default;
 
   // Iterates over |root_window| and all of its transient descendants.
   // Note |root_window| must not have a transient parent.
-  explicit TransientDescendantIterator(wm::WmWindow* root_window);
+  explicit TransientDescendantIterator(WmWindow* root_window);
 
   // Prefix increment operator.  This assumes there are more items (i.e.
   // *this != TransientDescendantIterator()).
   const TransientDescendantIterator& operator++();
 
   // Comparison for STL-based loops.
   bool operator!=(const TransientDescendantIterator& other) const;
 
   // Dereference operator for STL-compatible iterators.
-  wm::WmWindow* operator*() const;
+  WmWindow* operator*() const;
 
  private:
   // Explicit assignment operator defined because an explicit copy constructor
   // is needed and therefore the DISALLOW_COPY_AND_ASSIGN macro cannot be used.
   TransientDescendantIterator& operator=(
       const TransientDescendantIterator& other) = default;
 
   // The current window that |this| refers to. A null |current_window_| denotes
   // an empty iterator and is used as the last possible value in the traversal.
-  wm::WmWindow* current_window_;
+  WmWindow* current_window_;
 };
 
 // Provides a virtual container implementing begin() and end() for a sequence of
 // TransientDescendantIterators. This can be used in range-based for loops.
 class TransientDescendantIteratorRange {
  public:
   explicit TransientDescendantIteratorRange(
       const TransientDescendantIterator& begin);
 
   // Copy constructor required for iterator purposes.
@@ skipping 10 matching lines @@
       const TransientDescendantIteratorRange& other) = default;
 
   TransientDescendantIterator begin_;
   TransientDescendantIterator end_;
 };
 
 TransientDescendantIterator::TransientDescendantIterator()
   : current_window_(nullptr) {
 }
 
-TransientDescendantIterator::TransientDescendantIterator(
-    wm::WmWindow* root_window)
+TransientDescendantIterator::TransientDescendantIterator(WmWindow* root_window)
     : current_window_(root_window) {
   DCHECK(!root_window->GetTransientParent());
 }
 
 // Performs a pre-order traversal of the transient descendants.
 const TransientDescendantIterator&
 TransientDescendantIterator::operator++() {
   DCHECK(current_window_);
 
   const WmWindows transient_children = current_window_->GetTransientChildren();
 
   if (!transient_children.empty()) {
     current_window_ = transient_children.front();
   } else {
     while (current_window_) {
-      wm::WmWindow* parent = current_window_->GetTransientParent();
+      WmWindow* parent = current_window_->GetTransientParent();
       if (!parent) {
         current_window_ = nullptr;
         break;
       }
       const WmWindows transient_siblings = parent->GetTransientChildren();
       auto iter = std::find(transient_siblings.begin(),
                             transient_siblings.end(), current_window_);
       ++iter;
       if (iter != transient_siblings.end()) {
         current_window_ = *iter;
         break;
       }
       current_window_ = current_window_->GetTransientParent();
     }
   }
   return *this;
 }
 
 bool TransientDescendantIterator::operator!=(
     const TransientDescendantIterator& other) const {
   return current_window_ != other.current_window_;
 }
 
-wm::WmWindow* TransientDescendantIterator::operator*() const {
+WmWindow* TransientDescendantIterator::operator*() const {
   return current_window_;
 }
 
 TransientDescendantIteratorRange::TransientDescendantIteratorRange(
     const TransientDescendantIterator& begin)
     : begin_(begin) {
 }
 
-TransientDescendantIteratorRange GetTransientTreeIterator(
-    wm::WmWindow* window) {
+TransientDescendantIteratorRange GetTransientTreeIterator(WmWindow* window) {
   return TransientDescendantIteratorRange(
       TransientDescendantIterator(GetTransientRoot(window)));
 }
 
 }  // namespace
 
-ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(
-    wm::WmWindow* window)
+ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(WmWindow* window)
     : window_(window),
       minimized_(window->GetShowState() == ui::SHOW_STATE_MINIMIZED),
       ignored_by_shelf_(window->GetWindowState()->ignored_by_shelf()),
       overview_started_(false),
       original_transform_(window->GetTargetTransform()),
       original_opacity_(window->GetTargetOpacity()) {}
 
 ScopedTransformOverviewWindow::~ScopedTransformOverviewWindow() {
 }
 
@@ skipping 26 matching lines @@
 
 void ScopedTransformOverviewWindow::BeginScopedAnimation(
     OverviewAnimationType animation_type,
     ScopedAnimationSettings* animation_settings) {
   for (const auto& window : GetTransientTreeIterator(window_)) {
     animation_settings->push_back(
         CreateScopedOverviewAnimationSettings(animation_type, window));
   }
 }
 
-bool ScopedTransformOverviewWindow::Contains(const wm::WmWindow* target) const {
+bool ScopedTransformOverviewWindow::Contains(const WmWindow* target) const {
   for (const auto& window : GetTransientTreeIterator(window_)) {
     if (window->Contains(target))
       return true;
   }
   return false;
 }
 
 gfx::Rect ScopedTransformOverviewWindow::GetTargetBoundsInScreen() const {
   gfx::Rect bounds;
   for (const auto& window : GetTransientTreeIterator(window_)) {
@@ skipping 52 matching lines @@
   DCHECK(!src_rect.IsEmpty());
   gfx::Transform transform;
   transform.Translate(dst_rect.x() - src_rect.x(),
                       dst_rect.y() - src_rect.y());
   transform.Scale(static_cast<float>(dst_rect.width()) / src_rect.width(),
                   static_cast<float>(dst_rect.height()) / src_rect.height());
   return transform;
 }
 
 void ScopedTransformOverviewWindow::SetTransform(
-    wm::WmWindow* root_window,
+    WmWindow* root_window,
     const gfx::Transform& transform) {
   DCHECK(overview_started_);
 
   gfx::Point target_origin(GetTargetBoundsInScreen().origin());
 
   for (const auto& window : GetTransientTreeIterator(window_)) {
-    wm::WmWindow* parent_window = window->GetParent();
+    WmWindow* parent_window = window->GetParent();
     gfx::Point original_origin =
         parent_window->ConvertRectToScreen(window->GetTargetBounds()).origin();
     gfx::Transform new_transform = TransformAboutPivot(
         gfx::Point(target_origin.x() - original_origin.x(),
                    target_origin.y() - original_origin.y()),
         transform);
     window->SetTransform(new_transform);
   }
 }
 
 void ScopedTransformOverviewWindow::SetOpacity(float opacity) {
   for (const auto& window : GetTransientTreeIterator(window_)) {
     window->SetOpacity(opacity);
   }
 }
 
 void ScopedTransformOverviewWindow::Close() {
   GetTransientRoot(window_)->CloseWidget();
 }
 
 void ScopedTransformOverviewWindow::PrepareForOverview() {
   DCHECK(!overview_started_);
   overview_started_ = true;
   window_->GetWindowState()->set_ignored_by_shelf(true);
   ShowWindowIfMinimized();
 }
 
 }  // namespace ash