[ash-md] Erases the pre-MD code path for Overview Mode

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/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/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/overview/cleanup_animation_observer.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.h"
 #include "ash/common/wm/overview/window_selector_delegate.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"
@@ skipping 32 matching lines @@
   explicit WindowSelectorItemComparator(const WmWindow* target_window)
       : target(target_window) {}
 
   bool operator()(WindowSelectorItem* window) const {
     return window->GetWindow() == target;
   }
 
   const WmWindow* target;
 };
 
-// Conceptually the window overview is a table or grid of cells having this
-// fixed aspect ratio. The number of columns is determined by maximizing the
-// area of them based on the number of window_list.
-const float kCardAspectRatio = 4.0f / 3.0f;
-
-// The minimum number of cards along the major axis (i.e. horizontally on a
-// landscape orientation).
-const int kMinCardsMajor = 3;
-
-// Hiding window headers can be resource intensive. Only hide the headers when
-// the number of windows in this grid is less or equal than this number.
-// The default is 0, meaning that mask layers are never used and the bottom
-// corners are not rounded in overview.
-const int kMaxWindowsCountToHideHeaderWithMasks = 0;
-
+// Time it takes for the selector widget to move to the next target. The same
+// time is used for fading out shield widget when the overview mode is opened
+// or closed.
 const int kOverviewSelectorTransitionMilliseconds = 250;
 
 // The color and opacity of the screen shield in overview.
 const SkColor kShieldColor = SkColorSetARGB(255, 0, 0, 0);
 const float kShieldOpacity = 0.7f;
 
 // The color and opacity of the overview selector.
-const SkColor kWindowSelectionColor = SkColorSetARGB(128, 0, 0, 0);
-const SkColor kWindowSelectionColorMD = SkColorSetARGB(51, 255, 255, 255);
-const SkColor kWindowSelectionBorderColor = SkColorSetARGB(38, 255, 255, 255);
-const SkColor kWindowSelectionBorderColorMD = SkColorSetARGB(76, 255, 255, 255);
+const SkColor kWindowSelectionColor = SkColorSetARGB(51, 255, 255, 255);
+const SkColor kWindowSelectionBorderColor = SkColorSetARGB(76, 255, 255, 255);
 
 // Border thickness of overview selector.
-const int kWindowSelectionBorderThickness = 2;
-const int kWindowSelectionBorderThicknessMD = 1;
+const int kWindowSelectionBorderThickness = 1;
 
 // Corner radius of the overview selector border.
-const int kWindowSelectionRadius = 0;
-const int kWindowSelectionRadiusMD = 4;
-
-// The minimum amount of spacing between the bottom of the text filtering
-// text field and the top of the selection widget on the first row of items.
-const int kTextFilterBottomMargin = 5;
+const int kWindowSelectionRadius = 4;
 
 // In the conceptual overview table, the window margin is the space reserved
 // around the window within the cell. This margin does not overlap so the
 // closest distance between adjacent windows will be twice this amount.
-const int kWindowMarginMD = 5;
+const int kWindowMargin = 5;
 
 // Windows are not allowed to get taller than this.
 const int kMaxHeight = 512;
 
 // Margins reserved in the overview mode.
 const float kOverviewInsetRatio = 0.05f;
 
 // Additional vertical inset reserved for windows in overview mode.
 const float kOverviewVerticalInset = 0.1f;
 
@@ skipping 100 matching lines @@
   if (border_thickness_ > 0) {
     paint.setColor(border_color_);
     canvas->sk_canvas()->drawPath(stroke_path, paint);
   }
 }
 
 // Returns the vector for the fade in animation.
 gfx::Vector2d GetSlideVectorForFadeIn(WindowSelector::Direction direction,
                                       const gfx::Rect& bounds) {
   gfx::Vector2d vector;
-  const bool material = ash::MaterialDesignController::IsOverviewMaterial();
   switch (direction) {
     case WindowSelector::UP:
-      if (!material) {
-        vector.set_y(-bounds.height());
-        break;
-      }
     case WindowSelector::LEFT:
       vector.set_x(-bounds.width());
       break;
     case WindowSelector::DOWN:
-      if (!material) {
-        vector.set_y(bounds.height());
-        break;
-      }
     case WindowSelector::RIGHT:
       vector.set_x(bounds.width());
       break;
   }
   return vector;
 }
 
-// Given |root_window|, calculates the item size necessary to fit |items|
-// items in the window selection. |bounding_rect| is set to the centered
-// rectangle containing the grid and |item_size| is set to the size of each
-// individual item.
-void CalculateOverviewSizes(WmWindow* root_window,
-                            size_t items,
-                            int text_filter_bottom,
-                            gfx::Rect* bounding_rect,
-                            gfx::Size* item_size) {
-  gfx::Rect total_bounds = root_window->ConvertRectToScreen(
-      wm::GetDisplayWorkAreaBoundsInParent(root_window->GetChildByShellWindowId(
-          kShellWindowId_DefaultContainer)));
-
-  // Reserve space at the top for the text filtering textbox to appear.
-  total_bounds.Inset(0, text_filter_bottom + kTextFilterBottomMargin, 0, 0);
-
-  // Find the minimum number of windows per row that will fit all of the
-  // windows on screen.
-  int num_columns = std::max(
-      total_bounds.width() > total_bounds.height() ? kMinCardsMajor : 1,
-      static_cast<int>(ceil(sqrt(total_bounds.width() * items /
-                                 (kCardAspectRatio * total_bounds.height())))));
-  int num_rows = ((items + num_columns - 1) / num_columns);
-  item_size->set_width(std::min(
-      static_cast<int>(total_bounds.width() / num_columns),
-      static_cast<int>(total_bounds.height() * kCardAspectRatio / num_rows)));
-  item_size->set_height(
-      static_cast<int>(item_size->width() / kCardAspectRatio));
-  item_size->SetToMax(gfx::Size(1, 1));
-
-  bounding_rect->set_width(std::min(static_cast<int>(items), num_columns) *
-                           item_size->width());
-  bounding_rect->set_height(num_rows * item_size->height());
-  // Calculate the X and Y offsets necessary to center the grid.
-  bounding_rect->set_x(total_bounds.x() +
-                       (total_bounds.width() - bounding_rect->width()) / 2);
-  bounding_rect->set_y(total_bounds.y() +
-                       (total_bounds.height() - bounding_rect->height()) / 2);
-}
-
-// Reorders the list of windows |items| in |root_window| in an attempt to
-// minimize the distance each window will travel to enter overview. For
-// equidistant windows preserves a stable order between overview sessions
-// by comparing window pointers.
-void ReorderItemsGreedyLeastMovement(std::vector<WmWindow*>* items,
-                                     WmWindow* root_window,
-                                     int text_filter_bottom) {
-  if (items->empty())
-    return;
-  gfx::Rect bounding_rect;
-  gfx::Size item_size;
-  CalculateOverviewSizes(root_window, items->size(), text_filter_bottom,
-                         &bounding_rect, &item_size);
-  int num_columns = std::min(static_cast<int>(items->size()),
-                             bounding_rect.width() / item_size.width());
-  for (size_t i = 0; i < items->size(); ++i) {
-    int column = i % num_columns;
-    int row = i / num_columns;
-    gfx::Point overview_item_center(
-        bounding_rect.x() + column * item_size.width() + item_size.width() / 2,
-        bounding_rect.y() + row * item_size.height() + item_size.height() / 2);
-    // Find the nearest window for this position.
-    size_t swap_index = i;
-    int64_t shortest_distance = std::numeric_limits<int64_t>::max();
-    for (size_t j = i; j < items->size(); ++j) {
-      WmWindow* window = (*items)[j];
-      const gfx::Rect screen_target_bounds =
-          window->ConvertRectToScreen(window->GetTargetBounds());
-      int64_t distance =
-          (screen_target_bounds.CenterPoint() - overview_item_center)
-              .LengthSquared();
-      // We compare raw pointers to create a stable ordering given two windows
-      // with the same center point.
-      if (distance < shortest_distance ||
-          (distance == shortest_distance && window < (*items)[swap_index])) {
-        shortest_distance = distance;
-        swap_index = j;
-      }
-    }
-    if (swap_index > i)
-      std::swap((*items)[i], (*items)[swap_index]);
-  }
-}
-
 // Creates and returns a background translucent widget parented in
 // |root_window|'s default container and having |background_color|.
 // When |border_thickness| is non-zero, a border is created having
 // |border_color|, otherwise |border_color| parameter is ignored.
 // The new background widget starts with |initial_opacity| and then fades in.
 views::Widget* CreateBackgroundWidget(WmWindow* root_window,
                                       SkColor background_color,
                                       int border_thickness,
                                       int border_radius,
                                       SkColor border_color,
@@ skipping 14 matching lines @@
       widget, kShellWindowId_WallpaperContainer, &params);
   widget->Init(params);
   WmWindow* widget_window = WmLookup::Get()->GetWindowForWidget(widget);
   // Disable the "bounce in" animation when showing the window.
   widget_window->SetVisibilityAnimationTransition(::wm::ANIMATE_NONE);
   // The background widget should not activate the shelf when passing under it.
   widget_window->GetWindowState()->set_ignored_by_shelf(true);
 
   views::View* content_view =
       new RoundedRectView(border_radius, SK_ColorTRANSPARENT);
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    content_view->set_background(new BackgroundWith1PxBorder(
-        background_color, border_color, border_thickness, border_radius));
-  } else {
-    content_view->set_background(
-        views::Background::CreateSolidBackground(background_color));
-    if (border_thickness) {
-      content_view->SetBorder(
-          views::Border::CreateSolidBorder(border_thickness, border_color));
-    }
-  }
+  content_view->set_background(new BackgroundWith1PxBorder(
+      background_color, border_color, border_thickness, border_radius));
   widget->SetContentsView(content_view);
   widget_window->GetParent()->StackChildAtTop(widget_window);
   widget->Show();
   widget_window->SetOpacity(initial_opacity);
   return widget;
 }
 
 }  // namespace
 
 WindowGrid::WindowGrid(WmWindow* root_window,
                        const std::vector<WmWindow*>& windows,
                        WindowSelector* window_selector)
     : root_window_(root_window),
       window_selector_(window_selector),
       window_observer_(this),
       selected_index_(0),
       num_columns_(0),
       prepared_for_overview_(false) {
   std::vector<WmWindow*> windows_in_root;
   for (auto* window : windows) {
     if (window->GetRootWindow() == root_window)
       windows_in_root.push_back(window);
   }
 
-  if (!ash::MaterialDesignController::IsOverviewMaterial() &&
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshEnableStableOverviewOrder)) {
-    // Reorder windows to try to minimize movement to target overview positions.
-    // This also creates a stable window ordering.
-    ReorderItemsGreedyLeastMovement(&windows_in_root, root_window_,
-                                    window_selector_->text_filter_bottom());
-  }
-  PrepareForUsingMasksOrShapes(windows_in_root.size());
   for (auto* window : windows_in_root) {
     window_observer_.Add(window);
     window_list_.push_back(new WindowSelectorItem(window, window_selector_));
   }
 }
 
 WindowGrid::~WindowGrid() {}
 
 void WindowGrid::Shutdown() {
   for (auto iter = window_list_.begin(); iter != window_list_.end(); ++iter)
@@ skipping 20 matching lines @@
     std::unique_ptr<CleanupAnimationObserver> observer(
         new CleanupAnimationObserver(std::move(shield_widget_)));
     animation_settings.AddObserver(observer.get());
     window_selector_->delegate()->AddDelayedAnimationObserver(
         std::move(observer));
     shield_widget->SetOpacity(0.f);
   }
 }
 
 void WindowGrid::PrepareForOverview() {
-  if (ash::MaterialDesignController::IsOverviewMaterial())
-    InitShieldWidget();
+  InitShieldWidget();
   for (auto iter = window_list_.begin(); iter != window_list_.end(); ++iter)
     (*iter)->PrepareForOverview();
   prepared_for_overview_ = true;
 }
 
-void WindowGrid::PositionWindowsMD(bool animate) {
-  if (window_list_.empty())
+void WindowGrid::PositionWindows(bool animate) {
+  if (window_selector_->is_shut_down() || window_list_.empty())
     return;
-  PrepareForUsingMasksOrShapes(window_list_.size());
+  DCHECK(shield_widget_.get());
+  // Keep the background shield widget covering the whole screen.
+  WmWindow* widget_window =
+      WmLookup::Get()->GetWindowForWidget(shield_widget_.get());
+  const gfx::Rect bounds = widget_window->GetParent()->GetBounds();
+  widget_window->SetBounds(bounds);
   gfx::Rect total_bounds =
       root_window_->ConvertRectToScreen(wm::GetDisplayWorkAreaBoundsInParent(
           root_window_->GetChildByShellWindowId(
               kShellWindowId_DefaultContainer)));
   // Windows occupy vertically centered area with additional vertical insets.
   int horizontal_inset =
       gfx::ToFlooredInt(std::min(kOverviewInsetRatio * total_bounds.width(),
                                  kOverviewInsetRatio * total_bounds.height()));
   int vertical_inset =
       horizontal_inset +
       kOverviewVerticalInset * (total_bounds.height() - 2 * horizontal_inset);
-  total_bounds.Inset(std::max(0, horizontal_inset - kWindowMarginMD),
-                     std::max(0, vertical_inset - kWindowMarginMD));
+  total_bounds.Inset(std::max(0, horizontal_inset - kWindowMargin),
+                     std::max(0, vertical_inset - kWindowMargin));
   std::vector<gfx::Rect> rects;
 
   // Keep track of the lowest coordinate.
   int max_bottom = total_bounds.y();
 
   // Right bound of the narrowest row.
   int min_right = total_bounds.right();
   // Right bound of the widest row.
   int max_right = total_bounds.x();
 
   // Keep track of the difference between the narrowest and the widest row.
   // Initially this is set to the worst it can ever be assuming the windows fit.
   int width_diff = total_bounds.width();
 
   // Initially allow the windows to occupy all available width. Shrink this
   // available space horizontally to find the breakdown into rows that achieves
   // the minimal |width_diff|.
   int right_bound = total_bounds.right();
 
   // Determine the optimal height bisecting between |low_height| and
   // |high_height|. Once this optimal height is known, |height_fixed| is set to
   // true and the rows are balanced by repeatedly squeezing the widest row to
   // cause windows to overflow to the subsequent rows.
-  int low_height = 2 * kWindowMarginMD;
+  int low_height = 2 * kWindowMargin;
   int high_height =
       std::max(low_height, static_cast<int>(total_bounds.height() + 1));
   int height = 0.5 * (low_height + high_height);
   bool height_fixed = false;
 
   // Repeatedly try to fit the windows |rects| within |right_bound|.
   // If a maximum |height| is found such that all window |rects| fit, this
   // fitting continues while shrinking the |right_bound| in order to balance the
   // rows. If the windows fit the |right_bound| would have been decremented at
   // least once so it needs to be incremented once before getting out of this
   // loop and one additional pass made to actually fit the |rects|.
   // If the |rects| cannot fit (e.g. there are too many windows) the bisection
   // will still finish and we might increment the |right_bound| once pixel extra
   // which is acceptable since there is an unused margin on the right.
   bool make_last_adjustment = false;
   while (true) {
     gfx::Rect overview_bounds(total_bounds);
     overview_bounds.set_width(right_bound - total_bounds.x());
     bool windows_fit = FitWindowRectsInBounds(
-        overview_bounds, std::min(kMaxHeight + 2 * kWindowMarginMD, height),
+        overview_bounds, std::min(kMaxHeight + 2 * kWindowMargin, height),
         &rects, &max_bottom, &min_right, &max_right);
 
     if (height_fixed) {
       if (!windows_fit) {
         // Revert the previous change to |right_bound| and do one last pass.
         right_bound++;
         make_last_adjustment = true;
         break;
       }
       // Break if all the windows are zero-width at the current scale.
@@ skipping 26 matching lines @@
         break;
       }
     }
   }
   // Once the windows in |window_list_| no longer fit, the change to
   // |right_bound| was reverted. Perform one last pass to position the |rects|.
   if (make_last_adjustment) {
     gfx::Rect overview_bounds(total_bounds);
     overview_bounds.set_width(right_bound - total_bounds.x());
     FitWindowRectsInBounds(overview_bounds,
-                           std::min(kMaxHeight + 2 * kWindowMarginMD, height),
+                           std::min(kMaxHeight + 2 * kWindowMargin, height),
                            &rects, &max_bottom, &min_right, &max_right);
   }
   // Position the windows centering the left-aligned rows vertically.
   gfx::Vector2d offset(0, (total_bounds.bottom() - max_bottom) / 2);
   for (size_t i = 0; i < window_list_.size(); ++i) {
     window_list_[i]->SetBounds(
         rects[i] + offset,
         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);
 }
 
-void WindowGrid::PositionWindows(bool animate) {
-  if (window_selector_->is_shut_down())
-    return;
-
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    DCHECK(shield_widget_.get());
-    // Keep the background shield widget covering the whole screen.
-    WmWindow* widget_window =
-        WmLookup::Get()->GetWindowForWidget(shield_widget_.get());
-    const gfx::Rect bounds = widget_window->GetParent()->GetBounds();
-    widget_window->SetBounds(bounds);
-    PositionWindowsMD(animate);
-    return;
-  }
-  CHECK(!window_list_.empty());
-  gfx::Rect bounding_rect;
-  gfx::Size item_size;
-  CalculateOverviewSizes(root_window_, window_list_.size(),
-                         window_selector_->text_filter_bottom(), &bounding_rect,
-                         &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);
-  }
-
-  // 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;
   bool changed_selection_index = false;
-  const bool material = ash::MaterialDesignController::IsOverviewMaterial();
   gfx::Rect old_bounds;
   if (SelectedWindow()) {
     old_bounds = SelectedWindow()->target_bounds();
     // Make the old selected window header non-transparent first.
     SelectedWindow()->SetSelected(false);
   }
 
-  // With Material Design enabled [up] key is equivalent to [left] key and
-  // [down] key is equivalent to [right] key.
+  // [up] key is equivalent to [left] key and [down] key is equivalent to
+  // [right] key.
   if (!selection_widget_) {
     switch (direction) {
       case WindowSelector::UP:
-        if (!material) {
-          selected_index_ =
-              (window_list_.size() / num_columns_) * num_columns_ - 1;
-          break;
-        }
       case WindowSelector::LEFT:
         selected_index_ = window_list_.size() - 1;
         break;
       case WindowSelector::DOWN:
       case WindowSelector::RIGHT:
         selected_index_ = 0;
         break;
     }
     changed_selection_index = true;
   }
   while (!changed_selection_index ||
          (!out_of_bounds && window_list_[selected_index_]->dimmed())) {
     switch (direction) {
       case WindowSelector::UP:
-        if (!material) {
-          if (selected_index_ == 0)
-            out_of_bounds = true;
-          if (selected_index_ < num_columns_) {
-            selected_index_ +=
-                num_columns_ *
-                    ((window_list_.size() - selected_index_) / num_columns_) -
-                1;
-            recreate_selection_widget = true;
-          } else {
-            selected_index_ -= num_columns_;
-          }
-          break;
-        }
       case WindowSelector::LEFT:
         if (selected_index_ == 0)
           out_of_bounds = true;
         selected_index_--;
-        if (!material && (selected_index_ + 1) % num_columns_ == 0)
-          recreate_selection_widget = true;
         break;
       case WindowSelector::DOWN:
-        if (!material) {
-          selected_index_ += num_columns_;
-          if (selected_index_ >= window_list_.size()) {
-            selected_index_ = (selected_index_ + 1) % num_columns_;
-            if (selected_index_ == 0)
-              out_of_bounds = true;
-            recreate_selection_widget = true;
-          }
-          break;
-        }
       case WindowSelector::RIGHT:
         if (selected_index_ >= window_list_.size() - 1)
           out_of_bounds = true;
         selected_index_++;
-        if (!material && selected_index_ % num_columns_ == 0)
-          recreate_selection_widget = true;
         break;
     }
-    if (material) {
-      if (!out_of_bounds && SelectedWindow()) {
-        if (SelectedWindow()->target_bounds().y() != old_bounds.y())
-          recreate_selection_widget = true;
-      }
+    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);
 
   // Make the new selected window header fully transparent.
   if (SelectedWindow())
     SelectedWindow()->SetSelected(true);
   return out_of_bounds;
 }
 
 WindowSelectorItem* WindowGrid::SelectedWindow() const {
@@ skipping 79 matching lines @@
   // soon.
   if (!prepared_for_overview_)
     return;
 
   auto iter = std::find_if(window_list_.begin(), window_list_.end(),
                            WindowSelectorItemComparator(window));
   DCHECK(iter != window_list_.end());
 
   // Immediately finish any active bounds animation.
   window->StopAnimatingProperty(ui::LayerAnimationElement::BOUNDS);
-
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    PositionWindows(false);
-    return;
-  }
-  // Recompute the transform for the window.
-  (*iter)->RecomputeWindowTransforms();
+  PositionWindows(false);
 }
 
 void WindowGrid::InitShieldWidget() {
   // TODO(varkha): The code assumes that SHELF_BACKGROUND_MAXIMIZED is
   // synonymous with a black shelf background. Update this code if that
   // assumption is no longer valid.
   const float initial_opacity =
       (WmShelf::ForWindow(root_window_)->GetBackgroundType() ==
        SHELF_BACKGROUND_MAXIMIZED)
           ? 1.f
@@ skipping 11 matching lines @@
       widget_window->GetLayer()->GetAnimator());
   animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
       kOverviewSelectorTransitionMilliseconds));
   animation_settings.SetTweenType(gfx::Tween::EASE_IN);
   animation_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   shield_widget_->SetOpacity(kShieldOpacity);
 }
 
 void WindowGrid::InitSelectionWidget(WindowSelector::Direction direction) {
-  const bool material = ash::MaterialDesignController::IsOverviewMaterial();
-  const int border_thickness = material ? kWindowSelectionBorderThicknessMD
-                                        : kWindowSelectionBorderThickness;
-  const int border_color =
-      material ? kWindowSelectionBorderColorMD : kWindowSelectionBorderColor;
-  const int selection_color =
-      material ? kWindowSelectionColorMD : kWindowSelectionColor;
-  const int border_radius =
-      material ? kWindowSelectionRadiusMD : kWindowSelectionRadius;
-  selection_widget_.reset(
-      CreateBackgroundWidget(root_window_, selection_color, border_thickness,
-                             border_radius, border_color, 0.f));
+  selection_widget_.reset(CreateBackgroundWidget(
+      root_window_, kWindowSelectionColor, kWindowSelectionBorderThickness,
+      kWindowSelectionRadius, kWindowSelectionBorderColor, 0.f));
   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);
   widget_window->SetBounds(target_bounds - fade_out_direction);
   widget_window->SetName("OverviewModeSelector");
 
-  if (material) {
-    selector_shadow_.reset(new ::wm::Shadow());
-    selector_shadow_->Init(::wm::Shadow::STYLE_ACTIVE);
-    selector_shadow_->layer()->SetVisible(true);
-    selection_widget_->GetLayer()->SetMasksToBounds(false);
-    selection_widget_->GetLayer()->Add(selector_shadow_->layer());
-    selector_shadow_->SetContentBounds(gfx::Rect(target_bounds.size()));
-  }
+  selector_shadow_.reset(new ::wm::Shadow());
+  selector_shadow_->Init(::wm::Shadow::STYLE_ACTIVE);
+  selector_shadow_->layer()->SetVisible(true);
+  selection_widget_->GetLayer()->SetMasksToBounds(false);
+  selection_widget_->GetLayer()->Add(selector_shadow_->layer());
+  selector_shadow_->SetContentBounds(gfx::Rect(target_bounds.size()));
 }
 
 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.
@@ skipping 41 matching lines @@
 void WindowGrid::MoveSelectionWidgetToTarget(bool animate) {
   gfx::Rect bounds =
       root_window_->ConvertRectFromScreen(SelectedWindow()->target_bounds());
   if (animate) {
     WmWindow* selection_widget_window =
         WmLookup::Get()->GetWindowForWidget(selection_widget_.get());
     ui::ScopedLayerAnimationSettings animation_settings(
         selection_widget_window->GetLayer()->GetAnimator());
     animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
         kOverviewSelectorTransitionMilliseconds));
-    animation_settings.SetTweenType(
-        ash::MaterialDesignController::IsOverviewMaterial()
-            ? gfx::Tween::EASE_IN_OUT
-            : gfx::Tween::LINEAR_OUT_SLOW_IN);
+    animation_settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
     animation_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     selection_widget_->SetBounds(bounds);
     selection_widget_->SetOpacity(1.f);
 
     if (selector_shadow_) {
       ui::ScopedLayerAnimationSettings animation_settings_shadow(
           selector_shadow_->shadow_layer()->GetAnimator());
       animation_settings_shadow.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(
               kOverviewSelectorTransitionMilliseconds));
-      animation_settings_shadow.SetTweenType(
-          ash::MaterialDesignController::IsOverviewMaterial()
-              ? gfx::Tween::EASE_IN_OUT
-              : gfx::Tween::LINEAR_OUT_SLOW_IN);
+      animation_settings_shadow.SetTweenType(gfx::Tween::EASE_IN_OUT);
       animation_settings_shadow.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       bounds.Inset(1, 1);
       selector_shadow_->SetContentBounds(
           gfx::Rect(gfx::Point(1, 1), bounds.size()));
     }
     return;
   }
   selection_widget_->SetBounds(bounds);
   selection_widget_->SetOpacity(1.f);
@@ skipping 18 matching lines @@
   int top = bounds.y();
 
   // Keep track of the lowest coordinate.
   *max_bottom = bounds.y();
 
   // Right bound of the narrowest row.
   *min_right = bounds.right();
   // Right bound of the widest row.
   *max_right = bounds.x();
 
-  // With Material Design all elements are of same height and only the height is
-  // necessary to determine each item's scale.
+  // All elements are of same height and only the height is necessary to
+  // determine each item's scale.
   const gfx::Size item_size(0, height);
   size_t i = 0;
   for (auto* window : window_list_) {
     const gfx::Rect target_bounds = window->GetTargetBoundsInScreen();
     const int width =
         std::max(1, gfx::ToFlooredInt(target_bounds.width() *
                                       window->GetItemScale(item_size)) +
-                        2 * kWindowMarginMD);
+                        2 * kWindowMargin);
     if (left + width > bounds.right()) {
       // Move to the next row if possible.
       if (*min_right > left)
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
       top += height;
 
       // Check if the new row reaches the bottom or if the first item in the new
       // row does not fit within the available width.
@@ skipping 16 matching lines @@
       if (*min_right > left)
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
     }
     *max_bottom = top + height;
   }
   return windows_fit;
 }
 
-void WindowGrid::PrepareForUsingMasksOrShapes(size_t windows_count) const {
-  const int kUnlimited = -1;
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  int windows_to_use_masks = kMaxWindowsCountToHideHeaderWithMasks;
-  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseMaskInOverview) &&
-      (!base::StringToInt(command_line->GetSwitchValueASCII(
-                              switches::kAshMaxWindowsToUseMaskInOverview),
-                          &windows_to_use_masks) ||
-       windows_to_use_masks <= kUnlimited)) {
-    windows_to_use_masks = kMaxWindowsCountToHideHeaderWithMasks;
-  }
-  int windows_to_use_shapes = kUnlimited;
-  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseShapeInOverview) &&
-      (!base::StringToInt(command_line->GetSwitchValueASCII(
-                              switches::kAshMaxWindowsToUseShapeInOverview),
-                          &windows_to_use_shapes) ||
-       windows_to_use_shapes <= kUnlimited)) {
-    windows_to_use_shapes = kUnlimited;
-  }
-  WindowSelectorItem::set_use_mask(windows_to_use_masks <= kUnlimited ||
-                                   static_cast<int>(windows_count) <=
-                                       windows_to_use_masks);
-  WindowSelectorItem::set_use_shape(windows_to_use_shapes <= kUnlimited ||
-                                    static_cast<int>(windows_count) <=
-                                        windows_to_use_shapes);
-}
-
 }  // namespace ash