Allow Uber Tray popup pointing to the related tray item view.

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 225 matching lines @@
 }
 
 void SystemTray::AddTrayItem(SystemTrayItem* item) {
   items_.push_back(item);
 
   SystemTrayDelegate* delegate = Shell::GetInstance()->tray_delegate();
   views::View* tray_item = item->CreateTrayView(delegate->GetUserLoginStatus());
   if (tray_item) {
     tray_container_->AddChildViewAt(tray_item, 0);
     PreferredSizeChanged();
+    tray_item_map_[item] = tray_item;
   }
 }
 
 void SystemTray::RemoveTrayItem(SystemTrayItem* item) {
   NOTIMPLEMENTED();
 }
 
 void SystemTray::ShowDefaultView(BubbleCreationType creation_type) {
-  ShowItems(items_.get(), false, true, creation_type);
+  ShowDefaultViewWithOffset(creation_type, -1);
 }
 
 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);
+  ShowItems(items, true, activate, creation_type, GetTrayXOffset(item));
   bubble_->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::ShowNotificationView(SystemTrayItem* item) {
   if (std::find(notification_items_.begin(), notification_items_.end(), item)
       != notification_items_.end())
     return;
   notification_items_.push_back(item);
   UpdateNotificationBubble();
 }
@@ skipping 54 matching lines @@
     NOTREACHED();
   }
 }
 
 void SystemTray::SetPaintsBackground(
       bool value,
       internal::BackgroundAnimator::ChangeType change_type) {
   hide_background_animator_.SetPaintsBackground(value, change_type);
 }
 
+int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
+  std::map<SystemTrayItem*, views::View*>::const_iterator it =
+      tray_item_map_.find(item);
+  if (it == tray_item_map_.end())
+    return -1;
+
+  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;
+  }
+
+  // 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;
+}
+
+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) {
+                           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;
   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();
-    bubble_->InitView(tray_container_, SystemTrayBubble::ANCHOR_TYPE_TRAY,
-                      can_activate, delegate->GetUserLoginStatus());
+    views::View* anchor = tray_container_;
+    SystemTrayBubble::InitParams init_params(
+        SystemTrayBubble::ANCHOR_TYPE_TRAY);
+    init_params.anchor = anchor;
+    init_params.can_activate = can_activate;
+    init_params.login_status = delegate->GetUserLoginStatus();
+    if (arrow_offset >= 0)
+      init_params.arrow_offset = arrow_offset;
+    bubble_->InitView(init_params);
   }
   // If we have focus the shelf should be visible and we need to continue
   // showing the shelf when the popup is shown.
   if (GetWidget()->IsActive())
     should_show_launcher_ = true;
   UpdateNotificationBubble();  // State changed, re-create notifications.
 }
 
 void SystemTray::UpdateNotificationBubble() {
   // Only show the notification buble if we have notifications and we are not
   // showing the default bubble.
   if (notification_items_.empty() ||
       (bubble_.get() &&
        bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
     notification_bubble_.reset();
     return;
   }
   notification_bubble_.reset(
       new SystemTrayBubble(this, notification_items_,
                            SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
   views::View* anchor;
   SystemTrayBubble::AnchorType anchor_type;
   if (bubble_.get()) {
     anchor = bubble_->bubble_view();
     anchor_type = SystemTrayBubble::ANCHOR_TYPE_BUBBLE;
   } else {
     anchor = tray_container_;
     anchor_type = SystemTrayBubble::ANCHOR_TYPE_TRAY;
   }
-  notification_bubble_->InitView(
-      anchor, anchor_type,
-      false /* can_activate */,
-      ash::Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
+  SystemTrayBubble::InitParams init_params(anchor_type);
+  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);
 }
 
 void SystemTray::UpdateNotificationAnchor() {
   if (!notification_bubble_.get())
     return;
   notification_bubble_->bubble_view()->UpdateAnchor();
   // Ensure that the notification buble is above the launcher/status area.
   notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
 }
 
 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 {
-    ShowDefaultView(BUBBLE_CREATE_NEW);
+    int arrow_offset = -1;
+    if (event.IsMouseEvent() || event.IsTouchEvent()) {
+      const views::LocatedEvent& located_event =
+          static_cast<const views::LocatedEvent&>(event);
+      arrow_offset = base::i18n::IsRTL() ?
+          located_event.x() : tray_container_->width() - located_event.x();
+    }
+    ShowDefaultViewWithOffset(BUBBLE_CREATE_NEW, arrow_offset);
   }
   return true;
 }
 
 void SystemTray::OnMouseEntered(const views::MouseEvent& event) {
   should_show_launcher_ = true;
   hover_background_animator_.SetPaintsBackground(true,
       internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
@@ skipping 25 matching lines @@
     canvas->DrawFocusRect(tray_container_->bounds());
 }
 
 void SystemTray::UpdateBackground(int alpha) {
   background_->set_alpha(hide_background_animator_.alpha() +
                          hover_background_animator_.alpha());
   SchedulePaint();
 }
 
 }  // namespace ash