Adjust positioning of cros tray bubbles.

ash/common/system/tray/system_tray.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/common/system/tray/system_tray.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 29 matching lines @@
 #include "base/timer/timer.h"
 #include "grit/ash_strings.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/message_center/message_center_style.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/common/system/chromeos/audio/tray_audio.h"
 #include "ash/common/system/chromeos/bluetooth/tray_bluetooth.h"
 #include "ash/common/system/chromeos/brightness/tray_brightness.h"
 #include "ash/common/system/chromeos/cast/tray_cast.h"
@@ skipping 64 matching lines @@
 
 class SystemBubbleWrapper {
  public:
   // Takes ownership of |bubble|.
   explicit SystemBubbleWrapper(SystemTrayBubble* bubble)
       : bubble_(bubble), is_persistent_(false) {}
 
   // Initializes the bubble view and creates |bubble_wrapper_|.
   void InitView(TrayBackgroundView* tray,
                 views::View* anchor,
+                const gfx::Insets& anchor_insets,
                 TrayBubbleView::InitParams* init_params,
                 bool is_persistent) {
     DCHECK(anchor);
     LoginStatus login_status =
         WmShell::Get()->system_tray_delegate()->GetUserLoginStatus();
     bubble_->InitView(anchor, login_status, init_params);
+    bubble_->bubble_view()->set_anchor_view_insets(anchor_insets);
     bubble_wrapper_.reset(new TrayBubbleWrapper(tray, bubble_->bubble_view()));
-    // The system bubble should not have an arrow.
-    bubble_->bubble_view()->SetArrowPaintType(views::BubbleBorder::PAINT_NONE);
     is_persistent_ = is_persistent;
 
     // If ChromeVox is enabled, focus the default item if no item is focused and
     // there isn't a delayed close.
     if (WmShell::Get()->accessibility_delegate()->IsSpokenFeedbackEnabled() &&
         !is_persistent) {
       bubble_->FocusDefaultIfNeeded();
     }
   }
 
@@ skipping 191 matching lines @@
     PreferredSizeChanged();
     tray_item_map_[item] = tray_item;
   }
 }
 
 const std::vector<SystemTrayItem*>& SystemTray::GetTrayItems() const {
   return items_.get();
 }
 
 void SystemTray::ShowDefaultView(BubbleCreationType creation_type) {
-  ShowDefaultViewWithOffset(
-      creation_type, TrayBubbleView::InitParams::kArrowDefaultOffset, false);
+  if (creation_type != BUBBLE_USE_EXISTING)
+    WmShell::Get()->RecordUserMetricsAction(UMA_STATUS_AREA_MENU_OPENED);
+  ShowItems(items_.get(), false, true, creation_type, false);
 }
 
 void SystemTray::ShowPersistentDefaultView() {
-  ShowItems(items_.get(), false, false, BUBBLE_CREATE_NEW,
-            TrayBubbleView::InitParams::kArrowDefaultOffset, true);
+  ShowItems(items_.get(), false, false, BUBBLE_CREATE_NEW, true);
 }
 
 void SystemTray::ShowDetailedView(SystemTrayItem* item,
                                   int close_delay,
                                   bool activate,
                                   BubbleCreationType creation_type) {
   std::vector<SystemTrayItem*> items;
   // The detailed view with timeout means a UI to show the current system state,
   // like the audio level or brightness. Such UI should behave as persistent and
   // keep its own logic for the appearance.
   bool persistent =
       (!activate && close_delay > 0 && creation_type == BUBBLE_CREATE_NEW);
   items.push_back(item);
-  ShowItems(items, true, activate, creation_type, GetTrayXOffset(item),
-            persistent);
+  ShowItems(items, true, activate, creation_type, persistent);
   if (system_bubble_)
     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::SetDetailedViewCloseDelay(int close_delay) {
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED))
     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::HideDetailedView(SystemTrayItem* item, bool animate) {
@@ skipping 140 matching lines @@
 base::string16 SystemTray::GetAccessibleNameForTray() {
   base::string16 time = GetAccessibleTimeString(base::Time::Now());
   base::string16 battery = base::ASCIIToUTF16("");
 #if defined(OS_CHROMEOS)
   battery = PowerStatus::Get()->GetAccessibleNameString(false);
 #endif
   return l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBLE_DESCRIPTION,
                                     time, battery);
 }
 
-int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
-  // Don't attempt to align the arrow if the shelf is on the left or right.
-  if (!IsHorizontalAlignment(shelf_alignment()))
-    return TrayBubbleView::InitParams::kArrowDefaultOffset;
-
-  std::map<SystemTrayItem*, views::View*>::const_iterator it =
-      tray_item_map_.find(item);
-  if (it == tray_item_map_.end())
-    return TrayBubbleView::InitParams::kArrowDefaultOffset;
-
-  const views::View* item_view = it->second;
-  if (item_view->bounds().IsEmpty()) {
-    // The bounds of item could be still empty if it does not have a visible
-    // tray view. In that case, use the default (minimum) offset.
-    return TrayBubbleView::InitParams::kArrowDefaultOffset;
-  }
-
-  gfx::Point point(item_view->width() / 2, 0);
-  ConvertPointToWidget(item_view, &point);
-  return point.x();
-}
-
-void SystemTray::ShowDefaultViewWithOffset(BubbleCreationType creation_type,
-                                           int arrow_offset,
-                                           bool persistent) {
-  if (creation_type != BUBBLE_USE_EXISTING)
-    WmShell::Get()->RecordUserMetricsAction(UMA_STATUS_AREA_MENU_OPENED);
-  ShowItems(items_.get(), false, true, creation_type, arrow_offset, persistent);
-}
-
 void SystemTray::ShowItems(const std::vector<SystemTrayItem*>& items,
                            bool detailed,
                            bool can_activate,
                            BubbleCreationType creation_type,
-                           int arrow_offset,
                            bool persistent) {
   // No system tray bubbles in kiosk mode.
   if (WmShell::Get()->system_tray_delegate()->GetUserLoginStatus() ==
       LoginStatus::KIOSK_APP) {
     return;
   }
 
   // Destroy any existing bubble and create a new one.
   SystemTrayBubble::BubbleType bubble_type =
       detailed ? SystemTrayBubble::BUBBLE_TYPE_DETAILED
@@ skipping 22 matching lines @@
 
     // The menu width is fixed for all languages in material design.
     int menu_width = kMinimumSystemTrayMenuWidthMd;
     if (!MaterialDesignController::IsSystemTrayMenuMaterial()) {
       // The menu width is fixed, and it is a per language setting.
       menu_width = std::max(
           kMinimumSystemTrayMenuWidth,
           WmShell::Get()->system_tray_delegate()->GetSystemTrayMenuWidth());
     }
 
-    TrayBubbleView::InitParams init_params(TrayBubbleView::ANCHOR_TYPE_TRAY,
-                                           GetAnchorAlignment(), menu_width,
+    TrayBubbleView::InitParams init_params(GetAnchorAlignment(), menu_width,
                                            kTrayPopupMaxWidth);
     // TODO(oshima): Change TrayBubbleView itself.
     init_params.can_activate = false;
-    init_params.first_item_has_no_margin = true;
     if (detailed) {
       // This is the case where a volume control or brightness control bubble
       // is created.
       init_params.max_height = default_bubble_height_;
-      init_params.arrow_color = kBackgroundColor;
+      init_params.bg_color = kBackgroundColor;
     } else {
-      init_params.arrow_color = kHeaderBackgroundColor;
+      init_params.bg_color = kHeaderBackgroundColor;
     }
-    init_params.arrow_offset = arrow_offset;
     if (bubble_type == SystemTrayBubble::BUBBLE_TYPE_DEFAULT)
       init_params.close_on_deactivate = !persistent;
-    // For Volume and Brightness we don't want to show an arrow when
-    // they are shown in a bubble by themselves.
-    init_params.arrow_paint_type = views::BubbleBorder::PAINT_NORMAL;
-    if (items.size() == 1 && items[0]->ShouldHideArrow())
-      init_params.arrow_paint_type = views::BubbleBorder::PAINT_NONE;
     SystemTrayBubble* bubble = new SystemTrayBubble(this, items, bubble_type);
 
     system_bubble_.reset(new SystemBubbleWrapper(bubble));
-    system_bubble_->InitView(this, tray_container(), &init_params, persistent);
+    system_bubble_->InitView(this, GetBubbleAnchor(), GetBubbleAnchorInsets(),
+                             &init_params, persistent);
 
     activation_observer_.reset(persistent ? nullptr
                                           : new ActivationObserver(this));
 
     // Record metrics for the system menu when the default view is invoked.
     if (!detailed)
       RecordSystemMenuMetrics();
   }
   // Save height of default view for creating detailed views directly.
   if (!detailed)
@@ skipping 12 matching lines @@
   if (!notification_bubble_)
     UpdateWebNotifications();
   shelf()->UpdateAutoHideState();
 
   // When we show the system menu in our alternate shelf layout, we need to
   // tint the background.
   if (full_system_tray_menu_)
     SetIsActive(true);
 }
 
+// TODO(estade): there's only one thing that triggers a notification bubble,
+// and that's TraySms. We could delete a lot of code in SystemTray if that
+// used the message center notifications instead. See crbug.com/630641
 void SystemTray::UpdateNotificationBubble() {
   // Only show the notification bubble if we have notifications.
   if (notification_items_.empty()) {
     DestroyNotificationBubble();
     return;
   }
   // Destroy the existing bubble before constructing a new one.
   notification_bubble_.reset();
   SystemTrayBubble* notification_bubble;
   notification_bubble = new SystemTrayBubble(
       this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
-  views::View* anchor;
-  TrayBubbleView::AnchorType anchor_type;
   // Tray items might want to show notifications while we are creating and
   // initializing the |system_bubble_| - but it might not be fully initialized
   // when coming here - this would produce a crashed like crbug.com/247416.
   // As such we check the existence of the widget here.
+  TrayBubbleView::InitParams init_params(
+      GetAnchorAlignment(), kTrayPopupMinWidth, kTrayPopupMaxWidth);
+  views::View* anchor = GetBubbleAnchor();
+  gfx::Insets anchor_insets = GetBubbleAnchorInsets();
+  // If there's already a system menu bubble, stack this one on top.
   if (system_bubble_.get() && system_bubble_->bubble_view() &&
       system_bubble_->bubble_view()->GetWidget()) {
     anchor = system_bubble_->bubble_view();
-    anchor_type = TrayBubbleView::ANCHOR_TYPE_BUBBLE;
-  } else {
-    anchor = tray_container();
-    anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
+    anchor_insets.Set(-message_center::kMarginBetweenItems, 0, 0, 0);
+    init_params.anchor_alignment = TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
   }
-  TrayBubbleView::InitParams init_params(anchor_type, GetAnchorAlignment(),
-                                         kTrayPopupMinWidth,
-                                         kTrayPopupMaxWidth);
-  init_params.first_item_has_no_margin = true;
-  init_params.arrow_color = kBackgroundColor;
-  init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
+  init_params.bg_color = kBackgroundColor;
   notification_bubble_.reset(new SystemBubbleWrapper(notification_bubble));
-  notification_bubble_->InitView(this, anchor, &init_params, false);
+  notification_bubble_->InitView(this, anchor, anchor_insets, &init_params,
+                                 false);
 
   if (notification_bubble->bubble_view()->child_count() == 0) {
     // It is possible that none of the items generated actual notifications.
     DestroyNotificationBubble();
     return;
   }
   if (hide_notifications_)
     notification_bubble->SetVisible(false);
   else
     UpdateWebNotifications();
@@ skipping 92 matching lines @@
 
 void SystemTray::OnMouseExitedView() {
   if (system_bubble_)
     system_bubble_->bubble()->RestartAutoCloseTimer();
 }
 
 base::string16 SystemTray::GetAccessibleNameForBubble() {
   return GetAccessibleNameForTray();
 }
 
-gfx::Rect SystemTray::GetAnchorRect(
-    views::Widget* anchor_widget,
-    TrayBubbleView::AnchorType anchor_type,
-    TrayBubbleView::AnchorAlignment anchor_alignment) const {
-  return GetBubbleAnchorRect(anchor_widget, anchor_type, anchor_alignment);
-}
-
 void SystemTray::OnBeforeBubbleWidgetInit(
     views::Widget* anchor_widget,
     views::Widget* bubble_widget,
     views::Widget::InitParams* params) const {
   // Place the bubble in the same root window as |anchor_widget|.
   WmLookup::Get()
       ->GetWindowForWidget(anchor_widget)
       ->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           bubble_widget, kShellWindowId_SettingBubbleContainer, params);
@@ skipping 70 matching lines @@
   bubble_view->set_can_activate(true);
   bubble_view->GetWidget()->Activate();
 }
 
 bool SystemTray::PerformAction(const ui::Event& event) {
   // If we're already showing the default view, hide it; otherwise, show it
   // (and hide any popup that's currently shown).
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
     system_bubble_->bubble()->Close();
   } else {
-    int arrow_offset = TrayBubbleView::InitParams::kArrowDefaultOffset;
-    if (event.IsMouseEvent() || event.type() == ui::ET_GESTURE_TAP) {
-      const ui::LocatedEvent& located_event =
-          static_cast<const ui::LocatedEvent&>(event);
-      if (IsHorizontalAlignment(shelf_alignment())) {
-        gfx::Point point(located_event.x(), 0);
-        ConvertPointToWidget(this, &point);
-        arrow_offset = point.x();
-      }
-    }
-    ShowDefaultViewWithOffset(BUBBLE_CREATE_NEW, arrow_offset, false);
+    ShowDefaultView(BUBBLE_CREATE_NEW);
     if (event.IsKeyEvent() || (event.flags() & ui::EF_TOUCH_ACCESSIBILITY))
       ActivateBubble();
   }
   return true;
 }
 
 void SystemTray::CloseSystemBubbleAndDeactivateSystemTray() {
   CHECK(!activating_);
   activation_observer_.reset();
   key_event_watcher_.reset();
@@ skipping 27 matching lines @@
           .work_area()
           .height();
   if (work_area_height > 0) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Ash.SystemMenu.PercentageOfWorkAreaHeightCoveredByMenu",
         100 * bubble_view->height() / work_area_height, 1, 300, 100);
   }
 }
 
 }  // namespace ash