Update shelf spacing in Chrome OS according to the MD specs

ash/shelf/shelf_layout_manager.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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
 #include <vector>
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
+#include "ash/material_design/material_design_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
@@ skipping 54 matching lines @@
 // auto hidden shelf. The region is used to make it easier to trigger showing
 // the auto hidden shelf when the shelf is on the boundary between displays.
 const int kMaxAutoHideShowShelfRegionSize = 10;
 
 ui::Layer* GetLayer(views::Widget* widget) {
   return widget->GetNativeView()->layer();
 }
 
 }  // namespace
 
-// static
-const int ShelfLayoutManager::kWorkspaceAreaVisibleInset = 2;
-
-// static
-const int ShelfLayoutManager::kWorkspaceAreaAutoHideInset = 5;
-
-// static
-const int ShelfLayoutManager::kAutoHideSize = 3;
-
-// static
-const int ShelfLayoutManager::kShelfItemInset = 3;
-
 // ShelfLayoutManager::AutoHideEventFilter -------------------------------------
 
 // Notifies ShelfLayoutManager any time the mouse moves.
 class ShelfLayoutManager::AutoHideEventFilter : public ui::EventHandler {
  public:
   explicit AutoHideEventFilter(ShelfLayoutManager* shelf);
   ~AutoHideEventFilter() override;
 
   // Returns true if the last mouse event was a mouse drag.
   bool in_mouse_drag() const { return in_mouse_drag_; }
@@ skipping 165 matching lines @@
   return shelf_->status_area_widget() &&
       shelf_->status_area_widget()->IsVisible() &&
       (state_.visibility_state == SHELF_VISIBLE ||
        (state_.visibility_state == SHELF_AUTO_HIDE &&
         state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   gfx::Rect rect(ScreenUtil::GetDisplayBoundsInParent(shelf_->GetNativeView()));
   return SelectValueForShelfAlignment(
-      gfx::Rect(rect.x(), rect.bottom() - kShelfSize, rect.width(), kShelfSize),
-      gfx::Rect(rect.x(), rect.y(), kShelfSize, rect.height()),
-      gfx::Rect(rect.right() - kShelfSize, rect.y(), kShelfSize,
-                rect.height()));
+      gfx::Rect(rect.x(), rect.bottom() - GetShelfLayoutConstant(SHELF_SIZE),
+                rect.width(), GetShelfLayoutConstant(SHELF_SIZE)),
+      gfx::Rect(rect.x(), rect.y(), GetShelfLayoutConstant(SHELF_SIZE),
+                rect.height()),
+      gfx::Rect(rect.right() - GetShelfLayoutConstant(SHELF_SIZE), rect.y(),
+                GetShelfLayoutConstant(SHELF_SIZE), rect.height()));
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
   // Update insets in ShelfWindowTargeter when shelf bounds change.
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state()));
@@ skipping 239 matching lines @@
 
 bool ShelfLayoutManager::IsHorizontalAlignment() const {
   return wm::IsHorizontalAlignment(GetAlignment());
 }
 
 void ShelfLayoutManager::SetChromeVoxPanelHeight(int height) {
   chromevox_panel_height_ = height;
   LayoutShelf();
 }
 
+// static
+int ShelfLayoutManager::GetShelfItemInset(
+    ShelfLayoutManager::ShelfItemInset constant) {
+  const int kShelfItemInset[] = {3, 4};
+
+  int mode = MaterialDesignController::Mode::NON_MATERIAL;
+  if (MaterialDesignController::IsShelfMaterial())
+    mode = MaterialDesignController::Mode::MATERIAL_NORMAL;
+
+  switch (constant) {
+    case ShelfLayoutManager::ShelfItemInset::SHELF_ITEM_INSET:
+      return kShelfItemInset[mode];
+  }
+  NOTREACHED();
+  return 0;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds()
     : opacity(0.0f), status_opacity(0.0f) {}
 
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   if (!shelf_->GetNativeView())
@@ skipping 171 matching lines @@
     shelf_->status_area_widget()->Show();
 }
 
 void ShelfLayoutManager::StopAnimating() {
   GetLayer(shelf_)->GetAnimator()->StopAnimating();
   GetLayer(shelf_->status_area_widget())->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(const State& state,
                                                TargetBounds* target_bounds) {
-  int shelf_size = kShelfSize;
+  int shelf_size = GetShelfLayoutConstant(SHELF_SIZE);
   if (state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
     shelf_size = kAutoHideSize;
   } else if (state.visibility_state == SHELF_HIDDEN ||
              (!keyboard_bounds_.IsEmpty() &&
               !keyboard::IsKeyboardOverscrollEnabled())) {
     shelf_size = 0;
@@ skipping 12 matching lines @@
   gfx::Point shelf_origin = SelectValueForShelfAlignment(
       gfx::Point(available_bounds.x(), bottom_shelf_vertical_offset),
       gfx::Point(available_bounds.x(), available_bounds.y()),
       gfx::Point(available_bounds.right() - shelf_width, available_bounds.y()));
   target_bounds->shelf_bounds_in_root =
       gfx::Rect(shelf_origin.x(), shelf_origin.y(), shelf_width, shelf_height);
 
   gfx::Size status_size(
       shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (IsHorizontalAlignment())
-    status_size.set_height(kShelfSize);
+    status_size.set_height(GetShelfLayoutConstant(SHELF_SIZE));
   else
-    status_size.set_width(kShelfSize);
+    status_size.set_width(GetShelfLayoutConstant(SHELF_SIZE));
 
   gfx::Point status_origin = SelectValueForShelfAlignment(
       gfx::Point(0, 0),
       gfx::Point(shelf_width - status_size.width(),
                  shelf_height - status_size.height()),
       gfx::Point(0, shelf_height - status_size.height()));
   if (IsHorizontalAlignment() && !base::i18n::IsRTL())
     status_origin.set_x(shelf_width - status_size.width());
   target_bounds->status_bounds_in_shelf = gfx::Rect(status_origin, status_size);
 
@@ skipping 63 matching lines @@
       ScreenUtil::GetShelfDisplayBoundsInRoot(root_window_);
   int resistance_free_region = 0;
 
   if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
       visibility_state() == SHELF_AUTO_HIDE &&
       auto_hide_state() != SHELF_AUTO_HIDE_SHOWN) {
     // If the shelf was hidden when the drag started (and the state hasn't
     // changed since then, e.g. because the tray-menu was shown because of the
     // drag), then allow the drag some resistance-free region at first to make
     // sure the shelf sticks with the finger until the shelf is visible.
-    resistance_free_region = kShelfSize - kAutoHideSize;
+    resistance_free_region = GetShelfLayoutConstant(SHELF_SIZE) - kAutoHideSize;
   }
 
   bool resist = SelectValueForShelfAlignment(
       gesture_drag_amount_ < -resistance_free_region,
       gesture_drag_amount_ > resistance_free_region,
       gesture_drag_amount_ < -resistance_free_region);
 
   float translate = 0.f;
   if (resist) {
     float diff = fabsf(gesture_drag_amount_) - resistance_free_region;
@@ skipping 30 matching lines @@
     if (right_aligned) {
       target_bounds->shelf_bounds_in_root.set_x(
           available_bounds.right() - shelf_width);
     }
 
     if (right_aligned)
       target_bounds->status_bounds_in_shelf.set_x(0);
     else
       target_bounds->status_bounds_in_shelf.set_x(
           target_bounds->shelf_bounds_in_root.width() -
-          kShelfSize);
+          GetShelfLayoutConstant(SHELF_SIZE));
   }
 }
 
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimatorChangeType type) {
   const wm::ShelfBackgroundType background_type(GetShelfBackgroundType());
   shelf_->SetPaintsBackground(background_type, type);
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnBackgroundUpdated(background_type, type));
 }
@@ skipping 224 matching lines @@
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 }  // namespace ash