Ash:Shelf - Cleanup of Alternate Shelf (part 1)

ash/system/tray/tray_background_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/system/tray/tray_background_view.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 136 matching lines @@
   SkColor color() { return color_; }
   void set_color(SkColor color) { color_ = color; }
   void set_alpha(int alpha) { color_ = SkColorSetARGB(alpha, 0, 0, 0); }
 
  private:
   ShelfWidget* GetShelfWidget() const {
     return RootWindowController::ForWindow(tray_background_view_->
         status_area_widget()->GetNativeWindow())->shelf();
   }
 
-  void PaintForAlternateShelf(gfx::Canvas* canvas, views::View* view) const {
+  // Overridden from views::Background.
+  virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
     int orientation = kImageHorizontal;
     ShelfWidget* shelf_widget = GetShelfWidget();
     if (shelf_widget &&
         !shelf_widget->shelf_layout_manager()->IsHorizontalAlignment())
       orientation = kImageVertical;
 
     int state = kImageTypeDefault;
     if (tray_background_view_->draw_background_as_active())
       state = kImageTypePressed;
     else if (shelf_widget && shelf_widget->GetDimsShelf())
@@ skipping 35 matching lines @@
                          trailing_location.x(),
                          trailing_location.y());
 
     canvas->TileImageInt(*middle,
                          middle_bounds.x(),
                          middle_bounds.y(),
                          middle_bounds.width(),
                          middle_bounds.height());
   }
 
-  // Overridden from views::Background.
-  virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
-    if (ash::switches::UseAlternateShelfLayout()) {
-      PaintForAlternateShelf(canvas, view);
-    } else {
-      SkPaint paint;
-      paint.setAntiAlias(true);
-      paint.setStyle(SkPaint::kFill_Style);
-      paint.setColor(color_);
-      SkPath path;
-      gfx::Rect bounds(view->GetLocalBounds());
-      SkScalar radius = SkIntToScalar(kTrayRoundedBorderRadius);
-      path.addRoundRect(gfx::RectToSkRect(bounds), radius, radius);
-      canvas->DrawPath(path, paint);
-    }
-  }
-
   SkColor color_;
   // Reference to the TrayBackgroundView for which this is a background.
   TrayBackgroundView* tray_background_view_;
 
   // References to the images used as backgrounds, they are owned by the
   // resource bundle class.
   const gfx::ImageSkia* leading_images_[kNumOrientations][kNumStates];
   const gfx::ImageSkia* middle_images_[kNumOrientations][kNumStates];
   const gfx::ImageSkia* trailing_images_[kNumOrientations][kNumStates];
 
@@ skipping 31 matching lines @@
     const ViewHierarchyChangedDetails& details) {
   if (details.parent == this)
     PreferredSizeChanged();
 }
 
 void TrayBackgroundView::TrayContainer::UpdateLayout() {
   // Adjust the size of status tray dark background by adding additional
   // empty border.
   if (alignment_ == SHELF_ALIGNMENT_BOTTOM ||
       alignment_ == SHELF_ALIGNMENT_TOP) {
-    int vertical_padding = kTrayContainerVerticalPaddingBottomAlignment;
-    int horizontal_padding = kTrayContainerHorizontalPaddingBottomAlignment;
-    if (ash::switches::UseAlternateShelfLayout()) {
-      vertical_padding = kPaddingFromEdgeOfShelf;
-      horizontal_padding = kPaddingFromEdgeOfShelf;
-    }
     set_border(views::Border::CreateEmptyBorder(
-        vertical_padding,
-        horizontal_padding,
-        vertical_padding,
-        horizontal_padding));
+        kPaddingFromEdgeOfShelf,
+        kPaddingFromEdgeOfShelf,
+        kPaddingFromEdgeOfShelf,
+        kPaddingFromEdgeOfShelf));
 
     views::BoxLayout* layout =
         new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0);
     layout->set_spread_blank_space(true);
     views::View::SetLayoutManager(layout);
   } else {
-    int vertical_padding = kTrayContainerVerticalPaddingVerticalAlignment;
-    int horizontal_padding = kTrayContainerHorizontalPaddingVerticalAlignment;
-    if (ash::switches::UseAlternateShelfLayout()) {
-      vertical_padding = kPaddingFromEdgeOfShelf;
-      horizontal_padding = kPaddingFromEdgeOfShelf;
-    }
     set_border(views::Border::CreateEmptyBorder(
-        vertical_padding,
-        horizontal_padding,
-        vertical_padding,
-        horizontal_padding));
+        kPaddingFromEdgeOfShelf,
+        kPaddingFromEdgeOfShelf,
+        kPaddingFromEdgeOfShelf,
+        kPaddingFromEdgeOfShelf));
 
     views::BoxLayout* layout =
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
     layout->set_spread_blank_space(true);
     views::View::SetLayoutManager(layout);
   }
   PreferredSizeChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 33 matching lines @@
   GetWidget()->AddObserver(widget_observer_.get());
   SetBorder();
 }
 
 const char* TrayBackgroundView::GetClassName() const {
   return kViewClassName;
 }
 
 void TrayBackgroundView::OnMouseEntered(const ui::MouseEvent& event) {
   hovered_ = true;
-  if (!background_ || draw_background_as_active_ ||
-      ash::switches::UseAlternateShelfLayout())
-    return;
-  hover_background_animator_.SetPaintsBackground(
-      true, BACKGROUND_CHANGE_ANIMATE);
 }
 
 void TrayBackgroundView::OnMouseExited(const ui::MouseEvent& event) {
   hovered_ = false;
-  if (!background_ || draw_background_as_active_ ||
-      ash::switches::UseAlternateShelfLayout())
-    return;
-  hover_background_animator_.SetPaintsBackground(
-      false, BACKGROUND_CHANGE_ANIMATE);
 }
 
 void TrayBackgroundView::ChildPreferredSizeChanged(views::View* child) {
   PreferredSizeChanged();
 }
 
 void TrayBackgroundView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_PUSHBUTTON;
   state->name = GetAccessibleNameForTray();
 }
@@ skipping 13 matching lines @@
   // The tray itself expands to the right and bottom edge of the screen to make
   // sure clicking on the edges brings up the popup. However, the focus border
   // should be only around the container.
   return GetContentsBounds();
 }
 
 void TrayBackgroundView::UpdateBackground(int alpha) {
   // The animator should never fire when the alternate shelf layout is used.
   if (!background_ || draw_background_as_active_)
     return;
-  DCHECK(!ash::switches::UseAlternateShelfLayout());
   background_->set_alpha(hide_background_animator_.alpha() +
                          hover_background_animator_.alpha());
   SchedulePaint();
 }
 
 void TrayBackgroundView::SetContents(views::View* contents) {
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   AddChildView(contents);
 }
 
 void TrayBackgroundView::SetPaintsBackground(
     bool value, BackgroundAnimatorChangeType change_type) {
-  DCHECK(!ash::switches::UseAlternateShelfLayout());
   hide_background_animator_.SetPaintsBackground(value, change_type);
 }
 
 void TrayBackgroundView::SetContentsBackground() {
   background_ = new internal::TrayBackground(this);
   tray_container_->set_background(background_);
 }
 
 ShelfLayoutManager* TrayBackgroundView::GetShelfLayoutManager() {
   return ShelfLayoutManager::ForShelf(GetWidget()->GetNativeView());
 }
 
 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
   shelf_alignment_ = alignment;
   SetBorder();
   tray_container_->SetAlignment(alignment);
 }
 
 void TrayBackgroundView::SetBorder() {
   views::View* parent = status_area_widget_->status_area_widget_delegate();
   // Tray views are laid out right-to-left or bottom-to-top
   bool on_edge = (this == parent->child_at(0));
   int left_edge, top_edge, right_edge, bottom_edge;
-  if (ash::switches::UseAlternateShelfLayout()) {
-    if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
-      top_edge = ShelfLayoutManager::kShelfItemInset;
-      left_edge = 0;
-      bottom_edge = ShelfLayoutManager::GetPreferredShelfSize() -
-          ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
-      right_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
-    } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
-      top_edge = 0;
-      left_edge = ShelfLayoutManager::GetPreferredShelfSize() -
-          ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
-      bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
-      right_edge = ShelfLayoutManager::kShelfItemInset;
-    } else { // SHELF_ALIGNMENT_RIGHT
-      top_edge = 0;
-      left_edge = ShelfLayoutManager::kShelfItemInset;
-      bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
-      right_edge = ShelfLayoutManager::GetPreferredShelfSize() -
-          ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
-    }
-  } else {
-    // Change the border padding for different shelf alignment.
-    if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
-      top_edge = 0;
-      left_edge = 0;
-      bottom_edge = on_edge ? kPaddingFromBottomOfScreenBottomAlignment :
-          kPaddingFromBottomOfScreenBottomAlignment - 1;
-      right_edge = on_edge ? kPaddingFromRightEdgeOfScreenBottomAlignment : 0;
-    } else if (shelf_alignment() == SHELF_ALIGNMENT_TOP) {
-      top_edge = on_edge ? kPaddingFromBottomOfScreenBottomAlignment :
-          kPaddingFromBottomOfScreenBottomAlignment - 1;
-      left_edge = 0;
-      bottom_edge = 0;
-      right_edge = on_edge ? kPaddingFromRightEdgeOfScreenBottomAlignment : 0;
-    } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
-      top_edge = 0;
-      left_edge = kPaddingFromOuterEdgeOfLauncherVerticalAlignment;
-      bottom_edge = on_edge ? kPaddingFromBottomOfScreenVerticalAlignment : 0;
-      right_edge = kPaddingFromInnerEdgeOfLauncherVerticalAlignment;
-    } else {
-      top_edge = 0;
-      left_edge = kPaddingFromInnerEdgeOfLauncherVerticalAlignment;
-      bottom_edge = on_edge ? kPaddingFromBottomOfScreenVerticalAlignment : 0;
-      right_edge = kPaddingFromOuterEdgeOfLauncherVerticalAlignment;
-    }
+  if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
+    top_edge = ShelfLayoutManager::kShelfItemInset;
+    left_edge = 0;
+    bottom_edge = kShelfSize -
+        ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
+    right_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
+  } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
+    top_edge = 0;
+    left_edge = kShelfSize -
+        ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
+    bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
+    right_edge = ShelfLayoutManager::kShelfItemInset;
+  } else { // SHELF_ALIGNMENT_RIGHT
+    top_edge = 0;
+    left_edge = ShelfLayoutManager::kShelfItemInset;
+    bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
+    right_edge = kShelfSize -
+        ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
   }
   set_border(views::Border::CreateEmptyBorder(
       top_edge, left_edge, bottom_edge, right_edge));
 }
 
 void TrayBackgroundView::InitializeBubbleAnimations(
     views::Widget* bubble_widget) {
   views::corewm::SetWindowVisibilityAnimationType(
       bubble_widget->GetNativeWindow(),
       views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
@@ skipping 14 matching lines @@
 gfx::Rect TrayBackgroundView::GetBubbleAnchorRect(
     views::Widget* anchor_widget,
     TrayBubbleView::AnchorType anchor_type,
     TrayBubbleView::AnchorAlignment anchor_alignment) const {
   gfx::Rect rect;
   if (anchor_widget && anchor_widget->IsVisible()) {
     rect = anchor_widget->GetWindowBoundsInScreen();
     if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
         bool rtl = base::i18n::IsRTL();
-        if (!ash::switches::UseAlternateShelfLayout()) {
-          rect.Inset(
-              rtl ? kPaddingFromRightEdgeOfScreenBottomAlignment : 0,
-              kTrayBubbleAnchorTopInsetBottomAnchor,
-              rtl ? 0 : kPaddingFromRightEdgeOfScreenBottomAlignment,
-              kPaddingFromBottomOfScreenBottomAlignment);
-        } else {
-          rect.Inset(
-              rtl ? kAlternateLayoutBubblePaddingHorizontalSide : 0,
-              kAlternateLayoutBubblePaddingHorizontalBottom,
-              rtl ? 0 : kAlternateLayoutBubblePaddingHorizontalSide,
-              0);
-        }
+        rect.Inset(
+            rtl ? kBubblePaddingHorizontalSide : 0,
+            kBubblePaddingHorizontalBottom,
+            rtl ? 0 : kBubblePaddingHorizontalSide,
+            0);
       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
-        if (!ash::switches::UseAlternateShelfLayout()) {
-          rect.Inset(0, 0, kPaddingFromInnerEdgeOfLauncherVerticalAlignment + 5,
-                     kPaddingFromBottomOfScreenVerticalAlignment);
-        } else {
-          rect.Inset(0, 0, kAlternateLayoutBubblePaddingVerticalSide + 4,
-                     kAlternateLayoutBubblePaddingVerticalBottom);
-        }
+        rect.Inset(0, 0, kBubblePaddingVerticalSide + 4,
+                   kBubblePaddingVerticalBottom);
       } else {
-        if (!ash::switches::UseAlternateShelfLayout()) {
-          rect.Inset(kPaddingFromInnerEdgeOfLauncherVerticalAlignment + 1,
-                     0, 0, kPaddingFromBottomOfScreenVerticalAlignment);
-        } else {
-          rect.Inset(kAlternateLayoutBubblePaddingVerticalSide, 0, 0,
-                     kAlternateLayoutBubblePaddingVerticalBottom);
-        }
+        rect.Inset(kBubblePaddingVerticalSide, 0, 0,
+                   kBubblePaddingVerticalBottom);
       }
     } else if (anchor_type == TrayBubbleView::ANCHOR_TYPE_BUBBLE) {
       // Invert the offsets to align with the bubble below.
-      // Note that with the alternate shelf layout the tips are not shown and
-      // the offsets for left and right alignment do not need to be applied.
-      int vertical_alignment = ash::switches::UseAlternateShelfLayout() ?
-          0 :
-          kPaddingFromInnerEdgeOfLauncherVerticalAlignment;
-      int horizontal_alignment = ash::switches::UseAlternateShelfLayout() ?
-          kAlternateLayoutBubblePaddingVerticalBottom :
-          kPaddingFromBottomOfScreenVerticalAlignment;
+      int vertical_alignment = 0;
+      int horizontal_alignment = kBubblePaddingVerticalBottom;
       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT)
         rect.Inset(vertical_alignment, 0, 0, horizontal_alignment);
       else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT)
         rect.Inset(0, 0, vertical_alignment, horizontal_alignment);
     }
   }
 
   // TODO(jennyz): May need to add left/right alignment in the following code.
   if (rect.IsEmpty()) {
     aura::Window* target_root = anchor_widget ?
@@ skipping 20 matching lines @@
       return TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT;
     case SHELF_ALIGNMENT_TOP:
       return TrayBubbleView::ANCHOR_ALIGNMENT_TOP;
   }
   NOTREACHED();
   return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 }
 
 void TrayBackgroundView::SetDrawBackgroundAsActive(bool visible) {
   draw_background_as_active_ = visible;
-  if (!background_ || !switches::UseAlternateShelfLayout())
+  if (!background_)
     return;
 
   // Do not change gradually, changing color between grey and blue is weird.
   if (draw_background_as_active_)
     background_->set_color(kTrayBackgroundPressedColor);
   else if (hovered_)
     background_->set_alpha(kTrayBackgroundHoverAlpha);
   else
     background_->set_alpha(kTrayBackgroundAlpha);
   SchedulePaint();
 }
 
 void TrayBackgroundView::UpdateBubbleViewArrow(
     views::TrayBubbleView* bubble_view) {
-  if (switches::UseAlternateShelfLayout())
-    return;
-
-  aura::Window* root_window =
-      bubble_view->GetWidget()->GetNativeView()->GetRootWindow();
-  ash::internal::ShelfLayoutManager* shelf =
-      ShelfLayoutManager::ForShelf(root_window);
-  bubble_view->SetArrowPaintType(
-      (shelf && shelf->IsVisible()) ?
-      views::BubbleBorder::PAINT_NORMAL :
-      views::BubbleBorder::PAINT_TRANSPARENT);
 }
 
 }  // namespace internal
 }  // namespace ash