Shelf Cleanup AlternateShelfLayout P1 Attempt 3

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>
@@ skipping 76 matching lines @@
 // static
 const int ShelfLayoutManager::kWorkspaceAreaVisibleInset = 2;
 
 // static
 const int ShelfLayoutManager::kWorkspaceAreaAutoHideInset = 5;
 
 // static
 const int ShelfLayoutManager::kAutoHideSize = 3;
 
 // static
-const int ShelfLayoutManager::kShelfSize = 47;
-
-// static
 const int ShelfLayoutManager::kShelfItemInset = 3;
 
-int ShelfLayoutManager::GetPreferredShelfSize() {
-  return ash::switches::UseAlternateShelfLayout() ?
-      ShelfLayoutManager::kShelfSize : kShelfPreferredSize;
-}
-
 // ShelfLayoutManager::AutoHideEventFilter -------------------------------------
 
 // Notifies ShelfLayoutManager any time the mouse moves.
 class ShelfLayoutManager::AutoHideEventFilter : public ui::EventHandler {
  public:
   explicit AutoHideEventFilter(ShelfLayoutManager* shelf);
   virtual ~AutoHideEventFilter();
 
   // Returns true if the last mouse event was a mouse drag.
   bool in_mouse_drag() const { return in_mouse_drag_; }
@@ skipping 634 matching lines @@
 void ShelfLayoutManager::StopAnimating() {
   GetLayer(shelf_)->GetAnimator()->StopAnimating();
   GetLayer(shelf_->status_area_widget())->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::GetShelfSize(int* width, int* height) {
   *width = *height = 0;
   gfx::Size status_size(
       shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (IsHorizontalAlignment())
-    *height = GetPreferredShelfSize();
+    *height = kShelfSize;
   else
-    *width = GetPreferredShelfSize();
+    *width = kShelfSize;
 }
 
 void ShelfLayoutManager::AdjustBoundsBasedOnAlignment(int inset,
                                                       gfx::Rect* bounds) const {
   bounds->Inset(SelectValueForShelfAlignment(
       gfx::Insets(0, 0, inset, 0),
       gfx::Insets(0, inset, 0, 0),
       gfx::Insets(0, 0, 0, inset),
       gfx::Insets(inset, 0, 0, 0)));
 }
@@ skipping 31 matching lines @@
   target_bounds->shelf_bounds_in_root = SelectValueForShelfAlignment(
       gfx::Rect(available_bounds.x(), available_bounds.bottom() - shelf_height,
                     available_bounds.width(), shelf_height),
       gfx::Rect(available_bounds.x(), available_bounds.y(),
                     shelf_width, available_bounds.height()),
       gfx::Rect(available_bounds.right() - shelf_width, available_bounds.y(),
                     shelf_width, available_bounds.height()),
       gfx::Rect(available_bounds.x(), available_bounds.y(),
                     available_bounds.width(), shelf_height));
 
-  int status_inset = std::max(0, GetPreferredShelfSize() -
-      PrimaryAxisValue(status_size.height(), status_size.width()));
-
-  if (ash::switches::UseAlternateShelfLayout()) {
-    status_inset = 0;
-    if (IsHorizontalAlignment())
-      status_size.set_height(kShelfSize);
-    else
-      status_size.set_width(kShelfSize);
-  }
+  if (IsHorizontalAlignment())
+    status_size.set_height(kShelfSize);
+  else
+    status_size.set_width(kShelfSize);
 
   target_bounds->status_bounds_in_shelf = SelectValueForShelfAlignment(
       gfx::Rect(base::i18n::IsRTL() ? 0 : shelf_width - status_size.width(),
-                    status_inset, status_size.width(), status_size.height()),
-      gfx::Rect(shelf_width - (status_size.width() + status_inset),
+                    0, status_size.width(), status_size.height()),
+      gfx::Rect(shelf_width - status_size.width(),
                     shelf_height - status_size.height(), status_size.width(),
                     status_size.height()),
-      gfx::Rect(status_inset, shelf_height - status_size.height(),
+      gfx::Rect(0, shelf_height - status_size.height(),
                     status_size.width(), status_size.height()),
       gfx::Rect(base::i18n::IsRTL() ? 0 : shelf_width - status_size.width(),
-                    shelf_height - (status_size.height() + status_inset),
+                    shelf_height - status_size.height(),
                     status_size.width(), status_size.height()));
 
   target_bounds->work_area_insets = SelectValueForShelfAlignment(
       gfx::Insets(0, 0, GetWorkAreaSize(state, shelf_height), 0),
       gfx::Insets(0, GetWorkAreaSize(state, shelf_width), 0, 0),
       gfx::Insets(0, 0, 0, GetWorkAreaSize(state, shelf_width)),
       gfx::Insets(GetWorkAreaSize(state, shelf_height), 0, 0, 0));
 
   // TODO(varkha): The functionality of managing insets for display areas
   // should probably be pushed to a separate component. This would simplify or
@@ skipping 48 matching lines @@
   const gfx::Rect& available_bounds(root_window_->bounds());
   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 = GetPreferredShelfSize() - kAutoHideSize;
+    resistance_free_region = kShelfSize - kAutoHideSize;
   }
 
   bool resist = SelectValueForShelfAlignment(
       gesture_drag_amount_ < -resistance_free_region,
       gesture_drag_amount_ > resistance_free_region,
       gesture_drag_amount_ < -resistance_free_region,
       gesture_drag_amount_ > resistance_free_region);
 
   float translate = 0.f;
   if (resist) {
@@ skipping 10 matching lines @@
   if (horizontal) {
     // Move and size the shelf with the gesture.
     int shelf_height = target_bounds->shelf_bounds_in_root.height() - translate;
     shelf_height = std::max(shelf_height, kAutoHideSize);
     target_bounds->shelf_bounds_in_root.set_height(shelf_height);
     if (GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
       target_bounds->shelf_bounds_in_root.set_y(
           available_bounds.bottom() - shelf_height);
     }
 
-    if (ash::switches::UseAlternateShelfLayout()) {
-      target_bounds->status_bounds_in_shelf.set_y(0);
-    } else {
-      // The statusbar should be in the center of the shelf.
-      gfx::Rect status_y = target_bounds->shelf_bounds_in_root;
-      status_y.set_y(0);
-      status_y.ClampToCenteredSize(
-          target_bounds->status_bounds_in_shelf.size());
-      target_bounds->status_bounds_in_shelf.set_y(status_y.y());
-    }
+    target_bounds->status_bounds_in_shelf.set_y(0);
   } else {
     // Move and size the shelf with the gesture.
     int shelf_width = target_bounds->shelf_bounds_in_root.width();
     bool right_aligned = GetAlignment() == SHELF_ALIGNMENT_RIGHT;
     if (right_aligned)
       shelf_width -= translate;
     else
       shelf_width += translate;
     shelf_width = std::max(shelf_width, kAutoHideSize);
     target_bounds->shelf_bounds_in_root.set_width(shelf_width);
     if (right_aligned) {
       target_bounds->shelf_bounds_in_root.set_x(
           available_bounds.right() - shelf_width);
     }
 
-    if (ash::switches::UseAlternateShelfLayout()) {
-      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);
-    } else {
-      // The statusbar should be in the center of the shelf.
-      gfx::Rect status_x = target_bounds->shelf_bounds_in_root;
-      status_x.set_x(0);
-      status_x.ClampToCenteredSize(
-          target_bounds->status_bounds_in_shelf.size());
-      target_bounds->status_bounds_in_shelf.set_x(status_x.x());
-    }
+    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);
   }
 }
 
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimatorChangeType type) {
   const ShelfBackgroundType background_type(GetShelfBackgroundType());
   shelf_->SetPaintsBackground(background_type, type);
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnBackgroundUpdated(background_type, type));
 }
@@ skipping 209 matching lines @@
     base::AutoReset<ShelfVisibilityState> state(&state_.visibility_state,
                                                 SHELF_HIDDEN);
     TargetBounds target_bounds;
     CalculateTargetBounds(state_, &target_bounds);
     UpdateBoundsAndOpacity(target_bounds, true, NULL);
     UpdateVisibilityState();
   }
 }
 
 }  // namespace ash