Moves common code in ash/wm/overview to ash/common/wm/overview

ash/common/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 "ash/common/wm/overview/scoped_transform_overview_window.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
+#include "ash/common/wm/overview/scoped_overview_animation_settings.h"
+#include "ash/common/wm/overview/scoped_overview_animation_settings_factory.h"
+#include "ash/common/wm/overview/window_selector_item.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.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 "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/transform_util.h"
@@ skipping 24 matching lines @@
 }
 
 // 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;
+  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(WmWindow* root_window);
 
   // Prefix increment operator.  This assumes there are more items (i.e.
   // *this != TransientDescendantIterator()).
   const TransientDescendantIterator& operator++();
 
   // Comparison for STL-based loops.
@@ skipping 31 matching lines @@
   // Explicit assignment operator defined because an explicit copy constructor
   // is needed and therefore the DISALLOW_COPY_AND_ASSIGN macro cannot be used.
   TransientDescendantIteratorRange& operator=(
       const TransientDescendantIteratorRange& other) = default;
 
   TransientDescendantIterator begin_;
   TransientDescendantIterator end_;
 };
 
 TransientDescendantIterator::TransientDescendantIterator()
-  : current_window_(nullptr) {
-}
+    : current_window_(nullptr) {}
 
 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++() {
+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_) {
       WmWindow* parent = current_window_->GetTransientParent();
       if (!parent) {
@@ skipping 18 matching lines @@
     const TransientDescendantIterator& other) const {
   return current_window_ != other.current_window_;
 }
 
 WmWindow* TransientDescendantIterator::operator*() const {
   return current_window_;
 }
 
 TransientDescendantIteratorRange::TransientDescendantIteratorRange(
     const TransientDescendantIterator& begin)
-    : begin_(begin) {
-}
+    : begin_(begin) {}
 
 TransientDescendantIteratorRange GetTransientTreeIterator(WmWindow* window) {
   return TransientDescendantIteratorRange(
       TransientDescendantIterator(GetTransientRoot(window)));
 }
 
 }  // namespace
 
 // Mask layer that clips the window's original header in overview mode.
 // Only used with Material Design.
@@ skipping 69 matching lines @@
 }
 
 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() {
-}
+ScopedTransformOverviewWindow::~ScopedTransformOverviewWindow() {}
 
 void ScopedTransformOverviewWindow::RestoreWindow() {
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     window()->GetLayer()->SetMaskLayer(nullptr);
     mask_.reset();
   }
 
   ScopedAnimationSettings animation_settings_list;
-  BeginScopedAnimation(
-      OverviewAnimationType::OVERVIEW_ANIMATION_RESTORE_WINDOW,
-      &animation_settings_list);
+  BeginScopedAnimation(OverviewAnimationType::OVERVIEW_ANIMATION_RESTORE_WINDOW,
+                       &animation_settings_list);
   SetTransform(window()->GetRootWindow(), original_transform_, 0);
 
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       CreateScopedOverviewAnimationSettings(
           OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS,
           window_);
   gfx::Transform transform;
   if (minimized_ && window_->GetShowState() != ui::SHOW_STATE_MINIMIZED) {
     // Setting opacity 0 and visible false ensures that the property change
     // to SHOW_STATE_MINIMIZED will not animate the window from its original
@@ skipping 97 matching lines @@
                               bounds.height() - vertical_offset);
   return gfx::Rect(bounds.x() + horizontal_offset, bounds.y() + vertical_offset,
                    width, height);
 }
 
 gfx::Transform ScopedTransformOverviewWindow::GetTransformForRect(
     const gfx::Rect& src_rect,
     const gfx::Rect& dst_rect) {
   DCHECK(!src_rect.IsEmpty());
   gfx::Transform transform;
-  transform.Translate(dst_rect.x() - src_rect.x(),
-                      dst_rect.y() - src_rect.y());
+  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(
     WmWindow* root_window,
     const gfx::Transform& transform,
     int radius) {
   DCHECK(overview_started_);
 
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     mask_.reset(new OverviewContentMask(
         window()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET), radius));
     mask_->layer()->SetBounds(GetTargetBoundsInScreen());
     window()->GetLayer()->SetMaskLayer(mask_->layer());
   }
 
   gfx::Point target_origin(GetTargetBoundsInScreen().origin());
 
   for (const auto& window : GetTransientTreeIterator(window_)) {
     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);
+    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