Update shelf spacing in Chrome OS according to the MD specs

ash/shelf/shelf_view.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_view.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "ash/ash_constants.h"
@@ skipping 803 matching lines @@
   int available_size = shelf_->PrimaryAxisValue(width(), height());
   DCHECK(model_->item_count() == view_model_->view_size());
   if (!available_size)
     return;
 
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
   int x = 0;
   int y = 0;
-  int button_size = kShelfButtonSize;
-  int button_spacing = kShelfButtonSpacing;
+  int button_size = GetShelfConstant(SHELF_BUTTON_SIZE);
+  int button_spacing = GetShelfConstant(SHELF_BUTTON_SPACING);
 
   int w = shelf_->PrimaryAxisValue(button_size, width());
   int h = shelf_->PrimaryAxisValue(height(), button_size);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i < first_visible_index_) {
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
       continue;
     }
 
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
@@ skipping 579 matching lines @@
         view_model_->view_at(last_button_index)->bounds();
     if (overflow_button_->visible() &&
         model_->GetItemIndexForType(TYPE_APP_PANEL) == -1) {
       // When overflow button is visible and shelf has no panel items,
       // last_button_bounds should be overflow button's bounds.
       last_button_bounds = overflow_button_->bounds();
     }
 
     if (shelf_->IsHorizontalAlignment()) {
       preferred_size = gfx::Size(last_button_bounds.right() + leading_inset_,
-                                 kShelfSize);
+                                 GetShelfConstant(SHELF_SIZE));
     } else {
-      preferred_size = gfx::Size(kShelfSize,
+      preferred_size = gfx::Size(GetShelfConstant(SHELF_SIZE),
                                  last_button_bounds.bottom() + leading_inset_);
     }
   }
   gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
 
   // In overflow mode, we should use OverflowBubbleView as a source for
   // converting |origin| to screen coordinates. When a scroll operation is
   // occurred in OverflowBubble, the bounds of ShelfView in OverflowBubble can
   // be changed.
   if (is_overflow_mode())
@@ skipping 29 matching lines @@
   // If the modified view will be at the end of the list, return the new end of
   // the list.
   if (at_end)
     return view_model_->view_size();
   return modified_view ? view_model_->GetIndexOfView(modified_view) : -1;
 }
 
 gfx::Size ShelfView::GetPreferredSize() const {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
+  const int shelf_size = GetShelfConstant(SHELF_SIZE);
 
   int last_button_index = is_overflow_mode() ?
       last_visible_index_ : view_model_->view_size() - 1;
 
   // When an item is dragged off from the overflow bubble, it is moved to last
   // position and and changed to invisible. Overflow bubble size should be
   // shrunk to fit only for visible items.
   // If |dragged_off_from_overflow_to_shelf_| is set, there will be no invisible
   // items in the shelf.
   if (is_overflow_mode() &&
       dragged_off_shelf_ &&
       !dragged_off_from_overflow_to_shelf_ &&
       RemovableByRipOff(view_model_->GetIndexOfView(drag_view_)) == REMOVABLE)
     last_button_index--;
 
   const gfx::Rect last_button_bounds =
-      last_button_index  >= first_visible_index_ ?
-          view_model_->ideal_bounds(last_button_index) :
-          gfx::Rect(gfx::Size(kShelfSize, kShelfSize));
+      last_button_index >= first_visible_index_
+          ? view_model_->ideal_bounds(last_button_index)
+          : gfx::Rect(gfx::Size(shelf_size, shelf_size));
 
   if (shelf_->IsHorizontalAlignment())
-    return gfx::Size(last_button_bounds.right() + leading_inset_, kShelfSize);
+    return gfx::Size(last_button_bounds.right() + leading_inset_, shelf_size);
 
-  return gfx::Size(kShelfSize, last_button_bounds.bottom() + leading_inset_);
+  return gfx::Size(shelf_size, last_button_bounds.bottom() + leading_inset_);
 }
 
 void ShelfView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   // This bounds change is produced by the shelf movement and all content has
   // to follow. Using an animation at that time would produce a time lag since
   // the animation of the BoundsAnimator has itself a delay before it arrives
   // at the required location. As such we tell the animator to go there
   // immediately.
   BoundsAnimatorDisabler disabler(bounds_animator_.get());
   LayoutToIdealBounds();
@@ skipping 386 matching lines @@
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash