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

ash/common/wm/overview/window_grid.cc

 // Copyright 2014 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/window_grid.h"
+#include "ash/common/wm/overview/window_grid.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/overview/scoped_transform_overview_window.h"
+#include "ash/common/wm/overview/window_selector.h"
+#include "ash/common/wm/overview/window_selector_item.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_window.h"
-#include "ash/wm/overview/scoped_transform_overview_window.h"
-#include "ash/wm/overview/window_selector.h"
-#include "ash/wm/overview/window_selector_item.h"
 #include "base/command_line.h"
 #include "base/i18n/string_search.h"
 #include "base/memory/scoped_vector.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
@@ skipping 26 matching lines @@
  private:
   std::unique_ptr<views::Widget> widget_;
 
   DISALLOW_COPY_AND_ASSIGN(CleanupWidgetAfterAnimationObserver);
 };
 
 CleanupWidgetAfterAnimationObserver::CleanupWidgetAfterAnimationObserver(
     std::unique_ptr<views::Widget> widget)
     : widget_(std::move(widget)) {}
 
-CleanupWidgetAfterAnimationObserver::~CleanupWidgetAfterAnimationObserver() {
-}
+CleanupWidgetAfterAnimationObserver::~CleanupWidgetAfterAnimationObserver() {}
 
 void CleanupWidgetAfterAnimationObserver::OnImplicitAnimationsCompleted() {
   delete this;
 }
 
 // A comparator for locating a given target window.
 struct WindowSelectorItemComparator {
   explicit WindowSelectorItemComparator(const WmWindow* target_window)
       : target(target_window) {}
 
@@ skipping 507 matching lines @@
                          &item_size);
   num_columns_ = std::min(static_cast<int>(window_list_.size()),
                           bounding_rect.width() / item_size.width());
   for (size_t i = 0; i < window_list_.size(); ++i) {
     gfx::Transform transform;
     int column = i % num_columns_;
     int row = i / num_columns_;
     gfx::Rect target_bounds(item_size.width() * column + bounding_rect.x(),
                             item_size.height() * row + bounding_rect.y(),
                             item_size.width(), item_size.height());
-    window_list_[i]->SetBounds(target_bounds, animate ?
-        OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS :
-        OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
+    window_list_[i]->SetBounds(
+        target_bounds,
+        animate
+            ? OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS
+            : OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   }
 
   // If the selection widget is active, reposition it without any animation.
   if (selection_widget_)
     MoveSelectionWidgetToTarget(animate);
 }
 
 bool WindowGrid::Move(WindowSelector::Direction direction, bool animate) {
   bool recreate_selection_widget = false;
   bool out_of_bounds = false;
@@ skipping 72 matching lines @@
     }
     if (material) {
       if (!out_of_bounds && SelectedWindow()) {
         if (SelectedWindow()->target_bounds().y() != old_bounds.y())
           recreate_selection_widget = true;
       }
     }
     changed_selection_index = true;
   }
 
-  MoveSelectionWidget(direction, recreate_selection_widget,
-                      out_of_bounds, animate);
+  MoveSelectionWidget(direction, recreate_selection_widget, out_of_bounds,
+                      animate);
 
   // Make the new selected window header fully transparent.
   if (SelectedWindow())
     SelectedWindow()->SetSelected(true);
   return out_of_bounds;
 }
 
 WindowSelectorItem* WindowGrid::SelectedWindow() const {
   if (!selection_widget_)
     return nullptr;
@@ skipping 100 matching lines @@
       material ? kWindowSelectionRadiusMD : kWindowSelectionRadius;
   selection_widget_.reset(CreateBackgroundWidget(root_window_, selection_color,
                                                  border_thickness,
                                                  border_radius, border_color));
 
   WmWindow* widget_window =
       WmLookup::Get()->GetWindowForWidget(selection_widget_.get());
   const gfx::Rect target_bounds =
       root_window_->ConvertRectFromScreen(SelectedWindow()->target_bounds());
   gfx::Vector2d fade_out_direction =
-          GetSlideVectorForFadeIn(direction, target_bounds);
+      GetSlideVectorForFadeIn(direction, target_bounds);
   widget_window->SetBounds(target_bounds - fade_out_direction);
 }
 
 void WindowGrid::MoveSelectionWidget(WindowSelector::Direction direction,
                                      bool recreate_selection_widget,
                                      bool out_of_bounds,
                                      bool animate) {
   // If the selection widget is already active, fade it out in the selection
   // direction.
   if (selection_widget_ && (recreate_selection_widget || out_of_bounds)) {
     // Animate the old selection widget and then destroy it.
     views::Widget* old_selection = selection_widget_.get();
     WmWindow* old_selection_window =
         WmLookup::Get()->GetWindowForWidget(old_selection);
     gfx::Vector2d fade_out_direction =
         GetSlideVectorForFadeIn(direction, old_selection_window->GetBounds());
 
     ui::ScopedLayerAnimationSettings animation_settings(
         old_selection_window->GetLayer()->GetAnimator());
-    animation_settings.SetTransitionDuration(
-        base::TimeDelta::FromMilliseconds(
-            kOverviewSelectorTransitionMilliseconds));
+    animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
+        kOverviewSelectorTransitionMilliseconds));
     animation_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     animation_settings.SetTweenType(gfx::Tween::FAST_OUT_LINEAR_IN);
     // CleanupWidgetAfterAnimationObserver will delete itself (and the
     // widget) when the movement animation is complete.
     animation_settings.AddObserver(
         new CleanupWidgetAfterAnimationObserver(std::move(selection_widget_)));
     old_selection->SetOpacity(0.f);
     old_selection_window->SetBounds(old_selection_window->GetBounds() +
                                     fade_out_direction);
@@ skipping 96 matching lines @@
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
     }
     *max_bottom = top + height;
   }
   return windows_fit;
 }
 
 }  // namespace ash