Fix position of web notification bubble and arrow

ash/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/system/tray/system_tray.h"
 
 #include "ash/shell.h"
 #include "ash/shell/panel_window.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/tray_volume.h"
@@ skipping 12 matching lines @@
 #include "ash/system/tray/system_tray_bubble.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_item.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray_accessibility.h"
 #include "ash/system/tray_caps_lock.h"
 #include "ash/system/tray_update.h"
 #include "ash/system/user/login_status.h"
 #include "ash/system/user/tray_user.h"
 #include "ash/wm/shelf_layout_manager.h"
-#include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/events.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
@@ skipping 93 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayLayerAnimationObserver);
 };
 
 }  // namespace internal
 
 // SystemTray
 
 using internal::SystemTrayBubble;
 using internal::SystemTrayLayerAnimationObserver;
+using internal::TrayBubbleView;
 
 SystemTray::SystemTray()
     : items_(),
       accessibility_observer_(NULL),
       audio_observer_(NULL),
       bluetooth_observer_(NULL),
       brightness_observer_(NULL),
       caps_lock_observer_(NULL),
       clock_observer_(NULL),
       drive_observer_(NULL),
@@ skipping 92 matching lines @@
     PreferredSizeChanged();
     tray_item_map_[item] = tray_item;
   }
 }
 
 void SystemTray::RemoveTrayItem(SystemTrayItem* item) {
   NOTIMPLEMENTED();
 }
 
 void SystemTray::ShowDefaultView(BubbleCreationType creation_type) {
-  ShowDefaultViewWithOffset(creation_type, -1);
+  ShowDefaultViewWithOffset(creation_type,
+                            TrayBubbleView::InitParams::kArrowDefaultOffset);
 }
 
 void SystemTray::ShowDetailedView(SystemTrayItem* item,
                                   int close_delay,
                                   bool activate,
                                   BubbleCreationType creation_type) {
   std::vector<SystemTrayItem*> items;
   items.push_back(item);
   ShowItems(items, true, activate, creation_type, GetTrayXOffset(item));
   bubble_->StartAutoCloseTimer(close_delay);
@@ skipping 89 matching lines @@
         Shell::GetInstance()->shelf()->UpdateAutoHideState();
     }
   } else if (bubble == notification_bubble_) {
     notification_bubble_.reset();
   } else {
     NOTREACHED();
   }
 }
 
 int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
+  // Don't attempt to align the arrow if the shelf is on the left or right.
+  if (shelf_alignment() != SHELF_ALIGNMENT_BOTTOM)
+    return TrayBubbleView::InitParams::kArrowDefaultOffset;
+
   std::map<SystemTrayItem*, views::View*>::const_iterator it =
       tray_item_map_.find(item);
   if (it == tray_item_map_.end())
-    return -1;
+    return TrayBubbleView::InitParams::kArrowDefaultOffset;
 
   const views::View* item_view = it->second;
-  gfx::Rect item_bounds = item_view->bounds();
-  if (!item_bounds.IsEmpty()) {
-    int x_offset = item_bounds.x() + item_bounds.width() / 2;
-    return base::i18n::IsRTL() ? x_offset : tray_container_->width() - x_offset;
+  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;
   }
 
-  // The bounds of item could be still empty.  It could happen in the case that
-  // the view appears for the first time in the current session, because the
-  // bounds is not calculated yet. In that case, we want to guess the offset
-  // from the position of its parent.
-  int x_offset = 0;
-  for (int i = 0; i < tray_container_->child_count(); ++i) {
-    const views::View* child = tray_container_->child_at(i);
-    if (child == item_view)
-      return base::i18n::IsRTL() ?
-          x_offset : tray_container_->width() - x_offset;
-
-    if (!child->visible())
-      continue;
-    x_offset = child->bounds().right();
-  }
-
-  return -1;
+  gfx::Point point(item_view->width() / 2, 0);
+  ConvertPointToWidget(item_view, &point);
+  return point.x();
 }
 
 void SystemTray::ShowDefaultViewWithOffset(BubbleCreationType creation_type,
                                            int arrow_offset) {
   ShowItems(items_.get(), false, true, creation_type, arrow_offset);
 }
 
 void SystemTray::ShowItems(const std::vector<SystemTrayItem*>& items,
                            bool detailed,
                            bool can_activate,
                            BubbleCreationType creation_type,
                            int arrow_offset) {
   // Destroy any existing bubble and create a new one.
   SystemTrayBubble::BubbleType bubble_type = detailed ?
       SystemTrayBubble::BUBBLE_TYPE_DETAILED :
       SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
 
   // Destroy the notification bubble here so that it doesn't get rebuilt
   // while we add items to the main bubble_ (e.g. in HideNotificationView).
   notification_bubble_.reset();
 
   if (bubble_.get() && creation_type == BUBBLE_USE_EXISTING) {
     bubble_->UpdateView(items, bubble_type);
   } else {
     bubble_.reset(new SystemTrayBubble(this, items, bubble_type));
     ash::SystemTrayDelegate* delegate =
         ash::Shell::GetInstance()->tray_delegate();
     views::View* anchor = tray_container_;
-    SystemTrayBubble::InitParams init_params(
-        SystemTrayBubble::ANCHOR_TYPE_TRAY,
-        shelf_alignment());
-    init_params.anchor = anchor;
+    TrayBubbleView::InitParams init_params(TrayBubbleView::ANCHOR_TYPE_TRAY,
+                                           shelf_alignment());
     init_params.can_activate = can_activate;
-    init_params.login_status = delegate->GetUserLoginStatus();
-    if (arrow_offset >= 0)
-      init_params.arrow_offset = arrow_offset;
     if (detailed)
       init_params.max_height = default_bubble_height_;
-    bubble_->InitView(init_params);
+    init_params.arrow_offset = arrow_offset;
+    bubble_->InitView(anchor, init_params, delegate->GetUserLoginStatus());
   }
   // Save height of default view for creating detailed views directly.
   if (!detailed)
     default_bubble_height_ = bubble_->bubble_view()->height();
 
   if (detailed && items.size() > 0)
     detailed_item_ = items[0];
   else
     detailed_item_ = NULL;
 
@@ skipping 25 matching lines @@
         items.push_back(*iter);
     }
     notification_bubble_.reset(new SystemTrayBubble(
         this, items, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
   } else {
     // Show all notifications.
     notification_bubble_.reset(new SystemTrayBubble(
         this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
   }
   views::View* anchor;
-  SystemTrayBubble::AnchorType anchor_type;
+  TrayBubbleView::AnchorType anchor_type;
   if (bubble_.get()) {
     anchor = bubble_->bubble_view();
-    anchor_type = SystemTrayBubble::ANCHOR_TYPE_BUBBLE;
+    anchor_type = TrayBubbleView::ANCHOR_TYPE_BUBBLE;
   } else {
     anchor = tray_container_;
-    anchor_type = SystemTrayBubble::ANCHOR_TYPE_TRAY;
+    anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
   }
-  SystemTrayBubble::InitParams init_params(anchor_type, shelf_alignment());
-  init_params.anchor = anchor;
-  init_params.login_status =
-      ash::Shell::GetInstance()->tray_delegate()->GetUserLoginStatus();
-  int arrow_offset = GetTrayXOffset(notification_items_[0]);
-  if (arrow_offset >= 0)
-    init_params.arrow_offset = arrow_offset;
-  notification_bubble_->InitView(init_params);
+  TrayBubbleView::InitParams init_params(anchor_type, shelf_alignment());
+  init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
+  init_params.arrow_color = kBackgroundColor;
+  user::LoginStatus login_status =
+      Shell::GetInstance()->tray_delegate()->GetUserLoginStatus();
+  notification_bubble_->InitView(anchor, init_params, login_status);
   if (hide_notifications_)
     notification_bubble_->SetVisible(false);
 }
 
 void SystemTray::UpdateNotificationAnchor() {
   if (!notification_bubble_.get())
     return;
   notification_bubble_->bubble_view()->UpdateBubble();
   // Ensure that the notification buble is above the launcher/status area.
   notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
@@ skipping 18 matching lines @@
   }
 }
 
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   internal::TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
   SetBorder();
   tray_container_->UpdateLayout(alignment);
-  // Destroy an existing bubble so that it is rebuilt correctly.
+  // Destroy any existing bubble so that it is rebuilt correctly.
   bubble_.reset();
   // Rebuild any notification bubble.
   if (notification_bubble_.get()) {
     notification_bubble_.reset();
     UpdateNotificationBubble();
   }
 }
 
 bool SystemTray::PerformAction(const views::Event& event) {
   // If we're already showing the default view, hide it; otherwise, show it
   // (and hide any popup that's currently shown).
   if (bubble_.get() &&
       bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DEFAULT) {
     bubble_->Close();
   } else {
-    int arrow_offset = -1;
+    int arrow_offset = TrayBubbleView::InitParams::kArrowDefaultOffset;
     if (event.IsMouseEvent() || event.type() == ui::ET_GESTURE_TAP) {
       const views::LocatedEvent& located_event =
           static_cast<const views::LocatedEvent&>(event);
-      if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM)
-        arrow_offset = base::i18n::IsRTL() ?
-            located_event.x() : tray_container_->width() - located_event.x();
+      if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
+        gfx::Point point(located_event.x(), 0);
+        ConvertPointToWidget(this, &point);
+        arrow_offset = point.x();
+      }
     }
     ShowDefaultViewWithOffset(BUBBLE_CREATE_NEW, arrow_offset);
   }
   return true;
 }
 
 void SystemTray::OnMouseEntered(const views::MouseEvent& event) {
   TrayBackgroundView::OnMouseEntered(event);
   should_show_launcher_ = true;
 }
@@ skipping 19 matching lines @@
 
 void SystemTray::OnPaintFocusBorder(gfx::Canvas* canvas) {
   // 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.
   if (GetWidget() && GetWidget()->IsActive())
     DrawBorder(canvas, GetContentsBounds());
 }
 
 }  // namespace ash