Remove system tray specific code and arrow logic from SystemTrayBubbleView.

ash/system/tray/system_tray_bubble.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/system_tray_bubble.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
@@ skipping 28 matching lines @@
 
 const int kShadowThickness = 4;
 
 const int kBottomLineHeight = 1;
 
 const int kSystemTrayBubbleHorizontalInset = 1;
 const int kSystemTrayBubbleVerticalInset = 1;
 
 const int kArrowHeight = 10;
 const int kArrowWidth = 20;
-const int kArrowPaddingFromRight = 20;
-const int kArrowPaddingFromBottom = 17;
-const int kMinArrowOffset = 12;
+
+// Inset the arrow a bit from the edge.
+const int kArrowMinOffset = kArrowWidth / 2 + 4;
 
 const int kAnimationDurationForPopupMS = 200;
 
 // Normally a detailed view is the same size as the default view. However,
 // when showing a detailed view directly (e.g. clicking on a notification),
 // we may not know the height of the default view, or the default view may
 // be too short, so we use this as a default and minimum height for any
 // detailed view.
 const int kDetailedBubbleMaxHeight = kTrayPopupItemHeight * 5;
 
@@ skipping 86 matching lines @@
 };
 
 class SystemTrayBubbleBorder : public views::BubbleBorder {
  public:
   SystemTrayBubbleBorder(views::View* owner,
                          views::BubbleBorder::ArrowLocation arrow_location,
                          int arrow_offset)
       : views::BubbleBorder(arrow_location,
                             views::BubbleBorder::NO_SHADOW),
         owner_(owner),
-        arrow_offset_(std::max(arrow_offset, kMinArrowOffset)) {
+        tray_arrow_offset_(arrow_offset) {
     set_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   }
 
   virtual ~SystemTrayBubbleBorder() {}
 
  private:
   // Overridden from views::BubbleBorder.
   // Override views::BubbleBorder to set the bubble on top of the anchor when
   // it has no arrow.
   virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
@@ skipping 32 matching lines @@
 
     if (!Shell::GetInstance()->shelf()->IsVisible() ||
         arrow_location() == views::BubbleBorder::NONE)
       return;
 
     // Draw the arrow after drawing child borders, so that the arrow can cover
     // the its overlap section with child border.
     SkPath path;
     path.incReserve(4);
     if (arrow_location() == views::BubbleBorder::BOTTOM_RIGHT) {
-      int tip_x = base::i18n::IsRTL() ? arrow_offset_ :
-          owner_->width() - arrow_offset_;
-      if (tip_x < kArrowPaddingFromRight + kArrowWidth / 2)
-        tip_x = kArrowPaddingFromRight + kArrowWidth / 2;
-      if (tip_x > owner_->width() - kArrowPaddingFromRight - kArrowWidth / 2)
-        tip_x = owner_->width() - kArrowPaddingFromRight - kArrowWidth / 2;
+      int tip_x = base::i18n::IsRTL() ? tray_arrow_offset_ :
+          owner_->width() - tray_arrow_offset_;
+      tip_x = std::min(std::max(kArrowMinOffset, tip_x),
+                       owner_->width() - kArrowMinOffset);
       int left_base_x = tip_x - kArrowWidth / 2;
       int left_base_y = y;
       int tip_y = left_base_y + kArrowHeight;
       path.moveTo(SkIntToScalar(left_base_x), SkIntToScalar(left_base_y));
       path.lineTo(SkIntToScalar(tip_x), SkIntToScalar(tip_y));
       path.lineTo(SkIntToScalar(left_base_x + kArrowWidth),
                   SkIntToScalar(left_base_y));
-    } else if (arrow_location() == views::BubbleBorder::LEFT_BOTTOM) {
-      int tip_y = y - arrow_offset_;
+    } else {
+      int tip_y = y - tray_arrow_offset_;
+      tip_y = std::min(std::max(kArrowMinOffset, tip_y),
+                       owner_->height() - kArrowMinOffset);
       int top_base_y = tip_y - kArrowWidth / 2;
-      int top_base_x = inset.left() + kSystemTrayBubbleHorizontalInset;
-      int tip_x = top_base_x - kArrowHeight;
+      int top_base_x, tip_x;
+      if (arrow_location() == views::BubbleBorder::LEFT_BOTTOM) {
+        top_base_x = inset.left() + kSystemTrayBubbleHorizontalInset;
+        tip_x = top_base_x - kArrowHeight;
+      } else {
+        DCHECK(arrow_location() == views::BubbleBorder::RIGHT_BOTTOM);
+        top_base_x = inset.left() + owner_->width() -
+            kSystemTrayBubbleHorizontalInset;
+        tip_x = top_base_x + kArrowHeight;
+      }
       path.moveTo(SkIntToScalar(top_base_x), SkIntToScalar(top_base_y));
       path.lineTo(SkIntToScalar(tip_x), SkIntToScalar(tip_y));
       path.lineTo(SkIntToScalar(top_base_x),
-                  SkIntToScalar(top_base_y + kArrowWidth));
-    } else if (arrow_location() == views::BubbleBorder::RIGHT_BOTTOM){
-      int tip_y = y - arrow_offset_;
-      int top_base_y = tip_y - kArrowWidth / 2;
-      int top_base_x = inset.left() + owner_->width() -
-                       kSystemTrayBubbleHorizontalInset;
-      int tip_x = top_base_x + kArrowHeight;
-      path.moveTo(SkIntToScalar(top_base_x), SkIntToScalar(top_base_y));
-      path.lineTo(SkIntToScalar(tip_x), SkIntToScalar(tip_y));
-      path.lineTo(SkIntToScalar(top_base_x),
                   SkIntToScalar(top_base_y + kArrowWidth));
     }
 
     SkPaint paint;
     paint.setStyle(SkPaint::kFill_Style);
     paint.setColor(kHeaderBackgroundColorDark);
     canvas->DrawPath(path, paint);
 
     // Now draw the arrow border.
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setColor(kBorderDarkColor);
     canvas->DrawPath(path, paint);
 
   }
 
   views::View* owner_;
-  const int arrow_offset_;
+  const int tray_arrow_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBorder);
 };
 
 // Implicit animation observer that deletes itself and the layer at the end of
 // the animation.
 class AnimationObserverDeleteLayer : public ui::ImplicitAnimationObserver {
  public:
   explicit AnimationObserverDeleteLayer(ui::Layer* layer)
       : layer_(layer) {
@@ skipping 14 matching lines @@
 
 }  // namespace
 
 namespace internal {
 
 // SystemTrayBubbleView
 
 SystemTrayBubbleView::SystemTrayBubbleView(
     views::View* anchor,
     views::BubbleBorder::ArrowLocation arrow_location,
-    SystemTrayBubble* host,
-    bool can_activate)
+    Host* host,
+    bool can_activate,
+    int bubble_width)
     : views::BubbleDelegateView(anchor, arrow_location),
       host_(host),
       can_activate_(can_activate),
-      max_height_(0) {
+      max_height_(0),
+      bubble_width_(bubble_width) {
   set_margin(0);
   set_parent_window(ash::Shell::GetInstance()->GetContainer(
       ash::internal::kShellWindowId_SettingBubbleContainer));
   set_notify_enter_exit_on_child(true);
   SetPaintToLayer(true);
   SetFillsBoundsOpaquely(true);
 }
 
 SystemTrayBubbleView::~SystemTrayBubbleView() {
   // Inform host items (models) that their views are being destroyed.
   if (host_)
-    host_->DestroyItemViews();
+    host_->BubbleViewDestroyed();
 }
 
-void SystemTrayBubbleView::SetBubbleBorder(views::BubbleBorder* border) {
-  GetBubbleFrameView()->SetBubbleBorder(border);
+void SystemTrayBubbleView::SetBubbleBorder(int arrow_offset) {
+  DCHECK(GetWidget());
+  SystemTrayBubbleBorder* bubble_border = new SystemTrayBubbleBorder(
+      this, arrow_location(), arrow_offset);
+  GetBubbleFrameView()->SetBubbleBorder(bubble_border);
+  // Recalculate size with new border.
+  SizeToContents();
 }
 
 void SystemTrayBubbleView::UpdateAnchor() {
   SizeToContents();
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
+void SystemTrayBubbleView::SetMaxHeight(int height) {
+  max_height_ = height;
+  if (GetWidget())
+    SizeToContents();
+}
+
 void SystemTrayBubbleView::Init() {
   views::BoxLayout* layout =
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
   layout->set_spread_blank_space(true);
   SetLayoutManager(layout);
   set_background(NULL);
 }
 
 gfx::Rect SystemTrayBubbleView::GetAnchorRect() {
   gfx::Rect rect;
   if (host_)
     rect = host_->GetAnchorRect();
   // TODO(jennyz): May need to add left/right alignment in the following code.
   if (rect.IsEmpty()) {
     rect = gfx::Screen::GetPrimaryMonitor().bounds();
     rect = gfx::Rect(
         base::i18n::IsRTL() ? kPaddingFromRightEdgeOfScreenBottomAlignment :
             rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
         rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
         0, 0);
   }
   return rect;
 }
 
+gfx::Rect SystemTrayBubbleView::GetBubbleBounds() {
+  // Same as BubbleDelegateView implementation, but don't try mirroring.
+  return GetBubbleFrameView()->GetUpdatedWindowBounds(
+      GetAnchorRect(), GetPreferredSize(), false /*try_mirroring_arrow*/);
+}
+
 bool SystemTrayBubbleView::CanActivate() const {
   return can_activate_;
 }
 
 gfx::Size SystemTrayBubbleView::GetPreferredSize() {
   gfx::Size size = views::BubbleDelegateView::GetPreferredSize();
   int height = size.height();
   if (max_height_ != 0 && height > max_height_)
     height = max_height_;
-  return gfx::Size(kTrayPopupWidth, height);
+  return gfx::Size(bubble_width_, height);
 }
 
 void SystemTrayBubbleView::OnMouseEntered(const views::MouseEvent& event) {
   if (host_)
-    host_->StopAutoCloseTimer();
+    host_->OnMouseEnteredView();
 }
 
 void SystemTrayBubbleView::OnMouseExited(const views::MouseEvent& event) {
   if (host_)
-    host_->RestartAutoCloseTimer();
+    host_->OnMouseExitedView();
 }
 
 void SystemTrayBubbleView::GetAccessibleState(ui::AccessibleViewState* state) {
   if (can_activate_) {
     state->role = ui::AccessibilityTypes::ROLE_WINDOW;
     state->name = l10n_util::GetStringUTF16(
         IDS_ASH_STATUS_TRAY_ACCESSIBLE_NAME);
   }
 }
 
@@ skipping 12 matching lines @@
 }
 
 // SystemTrayBubble::InitParams
 SystemTrayBubble::InitParams::InitParams(
     SystemTrayBubble::AnchorType anchor_type,
     ShelfAlignment shelf_alignment)
     : anchor(NULL),
       anchor_type(anchor_type),
       can_activate(false),
       login_status(ash::user::LOGGED_IN_NONE),
-      arrow_offset(
-          (shelf_alignment == SHELF_ALIGNMENT_BOTTOM ?
-               kArrowPaddingFromRight : kArrowPaddingFromBottom)
-          + kArrowWidth / 2),
+      arrow_offset(0),
       max_height(0) {
 }
 
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
@@ skipping 75 matching lines @@
 
   DestroyItemViews();
   bubble_view_->RemoveAllChildViews(true);
 
   items_ = items;
   bubble_type_ = bubble_type;
   CreateItemViews(Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
   bubble_widget_->GetContentsView()->Layout();
   // Make sure that the bubble is large enough for the default view.
   if (bubble_type_ == BUBBLE_TYPE_DEFAULT) {
-    bubble_view_->set_max_height(0);  // Clear max height limit.
-    bubble_view_->SizeToContents();
+    bubble_view_->SetMaxHeight(0);  // Clear max height limit.
   }
 
   // When transitioning from default view to detailed view, animate the new
   // view (slide in from the right).
   if (bubble_type == BUBBLE_TYPE_DETAILED) {
     ui::Layer* new_layer = bubble_view_->layer();
     gfx::Rect bounds = new_layer->bounds();
     ui::Transform transform;
     transform.SetTranslateX(bounds.width());
     new_layer->SetTransform(transform);
@@ skipping 16 matching lines @@
       arrow_location = views::BubbleBorder::BOTTOM_RIGHT;
     } else if (tray_->shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
       arrow_location = views::BubbleBorder::LEFT_BOTTOM;
     } else {
       arrow_location = views::BubbleBorder::RIGHT_BOTTOM;
     }
   } else {
     arrow_location = views::BubbleBorder::NONE;
   }
   bubble_view_ = new SystemTrayBubbleView(
-      init_params.anchor, arrow_location, this, init_params.can_activate);
+      init_params.anchor, arrow_location,
+      this, init_params.can_activate, kTrayPopupWidth);
   if (bubble_type_ == BUBBLE_TYPE_NOTIFICATION)
     bubble_view_->set_close_on_deactivate(false);
   int max_height = init_params.max_height;
   if (bubble_type_ == BUBBLE_TYPE_DETAILED &&
       max_height < kDetailedBubbleMaxHeight)
     max_height = kDetailedBubbleMaxHeight;
-  bubble_view_->set_max_height(max_height);
+  bubble_view_->SetMaxHeight(max_height);
 
   CreateItemViews(init_params.login_status);
 
   DCHECK(bubble_widget_ == NULL);
   bubble_widget_ = views::BubbleDelegateView::CreateBubble(bubble_view_);
 
   // Must occur after call to CreateBubble()
   bubble_view_->SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble_widget_->non_client_view()->frame_view()->set_background(NULL);
-  SystemTrayBubbleBorder* bubble_border = new SystemTrayBubbleBorder(
-      bubble_view_, arrow_location, init_params.arrow_offset);
-  bubble_view_->SetBubbleBorder(bubble_border);
-  // Recalculate with new border.
-  bubble_view_->SizeToContents();
+  bubble_view_->SetBubbleBorder(init_params.arrow_offset);
 
   bubble_widget_->AddObserver(this);
 
   // Setup animation.
   ash::SetWindowVisibilityAnimationType(
       bubble_widget_->GetNativeWindow(),
       ash::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   ash::SetWindowVisibilityAnimationTransition(
       bubble_widget_->GetNativeWindow(),
       ash::ANIMATE_BOTH);
   ash::SetWindowVisibilityAnimationDuration(
       bubble_widget_->GetNativeWindow(),
       base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMS));
 
   bubble_view_->Show();
 }
 
+void SystemTrayBubble::BubbleViewDestroyed() {
+  DestroyItemViews();
+}
+
 gfx::Rect SystemTrayBubble::GetAnchorRect() const {
   gfx::Rect rect;
   views::Widget* widget = bubble_view()->anchor_widget();
   if (widget->IsVisible()) {
     rect = widget->GetWindowScreenBounds();
     if (anchor_type_ == ANCHOR_TYPE_TRAY) {
       if (tray_->shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
         rect.Inset(
             base::i18n::IsRTL() ?
                 kPaddingFromRightEdgeOfScreenBottomAlignment : 0,
@@ skipping 14 matching lines @@
       // be deducted out from the anchor rect.
       views::View* anchor_view = bubble_view()->anchor_view();
       rect = anchor_view->GetScreenBounds();
       gfx::Insets insets = anchor_view->GetInsets();
       rect.Inset(insets);
     }
   }
   return rect;
 }
 
+void SystemTrayBubble::OnMouseEnteredView() {
+  StopAutoCloseTimer();
+}
+
+void SystemTrayBubble::OnMouseExitedView() {
+  RestartAutoCloseTimer();
+}
+
 void SystemTrayBubble::DestroyItemViews() {
   for (std::vector<ash::SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     switch (bubble_type_) {
       case BUBBLE_TYPE_DEFAULT:
         (*it)->DestroyDefaultView();
         break;
       case BUBBLE_TYPE_DETAILED:
         (*it)->DestroyDetailedView();
@@ skipping 95 matching lines @@
 }
 
 void SystemTrayBubble::OnWidgetClosing(views::Widget* widget) {
   CHECK_EQ(bubble_widget_, widget);
   bubble_widget_ = NULL;
   tray_->RemoveBubble(this);
 }
 
 }  // namespace internal
 }  // namespace ash