Simplify ash shelf layout code.

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 30 matching lines @@
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/screen.h"
 #include "ui/keyboard/keyboard_util.h"
+#include "ui/views/border.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
 
 // To avoid hiding the shelf when the mouse transitions from a message bubble
@@ skipping 218 matching lines @@
       gfx::Rect(rect.right() - kShelfSize, rect.y(), kShelfSize, rect.height()),
       gfx::Rect(rect.x(), rect.y(), rect.width(), kShelfSize));
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
   if (shelf_->shelf()) {
-    // This is not part of UpdateBoundsAndOpacity() because
-    // SetShelfViewBounds() sets the bounds immediately and does not animate.
-    // The height of the ShelfView for a horizontal shelf and the width of
-    // the ShelfView for a vertical shelf are set when |shelf_|'s bounds
-    // are changed via UpdateBoundsAndOpacity(). This sets the origin and the
-    // dimension in the other direction.
-    shelf_->shelf()->SetShelfViewBounds(target_bounds.shelf_bounds_in_shelf);
     // Update insets in ShelfWindowTargeter when shelf bounds change.
     FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                       WillChangeVisibilityState(visibility_state()));
   }
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
   switch(auto_hide_behavior_) {
     case SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
 #if defined(OS_WIN)
@@ skipping 100 matching lines @@
 }
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_status_ = GESTURE_DRAG_IN_PROGRESS;
   gesture_drag_amount_ = 0.f;
   gesture_drag_auto_hide_state_ = visibility_state() == SHELF_AUTO_HIDE ?
       auto_hide_state() : SHELF_AUTO_HIDE_SHOWN;
   UpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
 }
 
-void ShelfLayoutManager::UpdateGestureDrag(
-    const ui::GestureEvent& gesture) {
-  bool horizontal = IsHorizontalAlignment();
-  gesture_drag_amount_ += horizontal ? gesture.details().scroll_y() :
-                                       gesture.details().scroll_x();
+void ShelfLayoutManager::UpdateGestureDrag(const ui::GestureEvent& gesture) {
+  gesture_drag_amount_ += PrimaryAxisValue(gesture.details().scroll_y(),
+                                           gesture.details().scroll_x());
   LayoutShelf();
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
   bool horizontal = IsHorizontalAlignment();
   bool should_change = false;
   if (gesture.type() == ui::ET_GESTURE_SCROLL_END) {
     // The visibility of the shelf changes only if the shelf was dragged X%
     // along the correct axis. If the shelf was already visible, then the
     // direction of the drag does not matter.
     const float kDragHideThreshold = 0.4f;
     gfx::Rect bounds = GetIdealBounds();
     float drag_ratio = fabs(gesture_drag_amount_) /
-                       (horizontal ?  bounds.height() : bounds.width());
+                       (horizontal ? bounds.height() : bounds.width());
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = drag_ratio > kDragHideThreshold;
     } else {
       bool correct_direction = false;
       switch (GetAlignment()) {
         case SHELF_ALIGNMENT_BOTTOM:
         case SHELF_ALIGNMENT_RIGHT:
           correct_direction = gesture_drag_amount_ < 0;
           break;
         case SHELF_ALIGNMENT_LEFT:
@@ skipping 243 matching lines @@
     // illegal state. We therefore hide the shelf here if required.
     if (!target_bounds.status_opacity)
       shelf_->status_area_widget()->Hide();
     // Setting visibility during an animation causes the visibility property to
     // animate. Override the animation settings to immediately set the
     // visibility property. Opacity will still animate.
 
     // TODO(harrym): Once status area widget is a child view of shelf
     // this can be simplified.
     gfx::Rect status_bounds = target_bounds.status_bounds_in_shelf;
-    status_bounds.set_x(status_bounds.x() +
-                        target_bounds.shelf_bounds_in_root.x());
-    status_bounds.set_y(status_bounds.y() +
-                        target_bounds.shelf_bounds_in_root.y());
+    status_bounds.Offset(target_bounds.shelf_bounds_in_root.OffsetFromOrigin());
     // mash::wm::ShelfLayout manages window bounds when running mash_shell.
     if (!aura::GetMusWindow(shelf_->GetNativeWindow())) {
       shelf_->status_area_widget()->SetBounds(
           ScreenUtil::ConvertRectToScreen(
               shelf_->status_area_widget()->GetNativeView()->parent(),
               status_bounds));
     }
     if (!state_.is_screen_locked) {
       gfx::Insets insets;
       // If user session is blocked (login to new user session or add user to
       // the existing session - multi-profile) then give 100% of work area only
       // if keyboard is not shown.
-      if (!state_.is_adding_user_screen || !keyboard_bounds_.IsEmpty()) {
+      if (!state_.is_adding_user_screen || !keyboard_bounds_.IsEmpty())
         insets = target_bounds.work_area_insets;
-      }
       Shell::GetInstance()->SetDisplayWorkAreaInsets(root_window_, insets);
     }
   }
 
+  // Set an empty border to avoid the shelf view and status area overlapping.
+  // TODO(msw): Avoid setting bounds of views within the shelf widget here.
+  gfx::Rect shelf_bounds = gfx::Rect(target_bounds.shelf_bounds_in_root.size());
+  shelf_->GetContentsView()->SetBorder(views::Border::CreateEmptyBorder(
+      shelf_bounds.InsetsFrom(target_bounds.shelf_bounds_in_shelf)));
+  shelf_->GetContentsView()->Layout();
+
   // Setting visibility during an animation causes the visibility property to
   // animate. Set the visibility property without an animation.
   if (target_bounds.status_opacity)
     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) {
-  gfx::Rect available_bounds =
-      ScreenUtil::GetShelfDisplayBoundsInRoot(root_window_);
-  gfx::Rect status_size(
-      shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
-  int shelf_width = PrimaryAxisValue(available_bounds.width(), kShelfSize);
-  int shelf_height = PrimaryAxisValue(kShelfSize, available_bounds.height());
-
+  int shelf_size = kShelfSize;
   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.
-    if (IsHorizontalAlignment())
-      shelf_height = kAutoHideSize;
-    else
-      shelf_width = kAutoHideSize;
+    shelf_size = kAutoHideSize;
   } else if (state.visibility_state == SHELF_HIDDEN ||
-      (!keyboard_bounds_.IsEmpty() && !keyboard::IsKeyboardOverscrollEnabled()))
-  {
-    if (IsHorizontalAlignment())
-      shelf_height = 0;
-    else
-      shelf_width = 0;
+             (!keyboard_bounds_.IsEmpty() &&
+              !keyboard::IsKeyboardOverscrollEnabled())) {
+    shelf_size = 0;
   }
 
+  gfx::Rect available_bounds =
+      ScreenUtil::GetShelfDisplayBoundsInRoot(root_window_);
+  int shelf_width = PrimaryAxisValue(available_bounds.width(), shelf_size);
+  int shelf_height = PrimaryAxisValue(shelf_size, available_bounds.height());
   int bottom_shelf_vertical_offset = available_bounds.bottom();
   if (keyboard_bounds_.IsEmpty())
     bottom_shelf_vertical_offset -= shelf_height;
   else
     bottom_shelf_vertical_offset -= keyboard_bounds_.height();
 
-  target_bounds->shelf_bounds_in_root = SelectValueForShelfAlignment(
-      gfx::Rect(available_bounds.x(), bottom_shelf_vertical_offset,
-                    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));
+  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()),
+      gfx::Point(available_bounds.x(), 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);
   else
     status_size.set_width(kShelfSize);
 
-  target_bounds->status_bounds_in_shelf = SelectValueForShelfAlignment(
-      gfx::Rect(base::i18n::IsRTL() ? 0 : shelf_width - status_size.width(),
-                    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(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_size.width(), status_size.height()));
+  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()),
+      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);
 
   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
   // remove entirely the dependency on keyboard and dock.
@@ skipping 48 matching lines @@
   available_bounds.Subtract(target_bounds->shelf_bounds_in_root);
   available_bounds.Subtract(keyboard_bounds_);
   user_work_area_bounds_ =
       ScreenUtil::ConvertRectToScreen(root_window_, available_bounds);
 }
 
 void ShelfLayoutManager::UpdateTargetBoundsForGesture(
     TargetBounds* target_bounds) const {
   CHECK_EQ(GESTURE_DRAG_IN_PROGRESS, gesture_drag_status_);
   bool horizontal = IsHorizontalAlignment();
-  const gfx::Rect& available_bounds(root_window_->bounds());
+  gfx::Rect available_bounds =
+      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;
@@ skipping 308 matching lines @@
     return false;
   }
   if (session_state_delegate->IsUserSessionBlocked() ||
       state_.is_adding_user_screen) {
     return true;
   }
   return false;
 }
 
 }  // namespace ash