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

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 158 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBackground);
 };
 
 class SystemTrayBubbleBorder : public views::BubbleBorder {
  public:
   enum ArrowType {
     ARROW_TYPE_NONE,
     ARROW_TYPE_BOTTOM,
   };
 
-  SystemTrayBubbleBorder(views::View* owner, ArrowType arrow_type)
+  SystemTrayBubbleBorder(views::View* owner,
+                         ArrowType arrow_type,
+                         int arrow_offset)
       : views::BubbleBorder(views::BubbleBorder::BOTTOM_RIGHT,
                             views::BubbleBorder::NO_SHADOW),
         owner_(owner),
-        arrow_type_(arrow_type) {
+        arrow_type_(arrow_type),
+        arrow_offset_(arrow_offset) {
     set_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   }
 
   virtual ~SystemTrayBubbleBorder() {}
 
  private:
   // Overridden from views::Border.
   virtual void Paint(const views::View& view,
                      gfx::Canvas* canvas) const OVERRIDE {
     gfx::Insets inset;
     GetInsets(&inset);
     DrawBlurredShadowAroundView(canvas, 0, owner_->height(), owner_->width(),
         inset);
 
     // Draw the bottom line.
     int y = owner_->height() + 1;
     canvas->FillRect(gfx::Rect(kLeftPadding, y, owner_->width(),
                                kBottomLineHeight), kBorderDarkColor);
 
     if (!Shell::GetInstance()->shelf()->IsVisible())
       return;
 
     // Draw the arrow.
     if (arrow_type_ == ARROW_TYPE_BOTTOM) {
-      int left_base_x = base::i18n::IsRTL() ? kArrowWidth :
-          owner_->width() - kArrowPaddingFromRight - kArrowWidth;
+      int tip_x = base::i18n::IsRTL() ? arrow_offset_ :
+          owner_->width() - arrow_offset_;
+      int left_base_x = tip_x - kArrowWidth / 2;
       int left_base_y = y;
-      int tip_x = left_base_x + kArrowWidth / 2;
       int tip_y = left_base_y + kArrowHeight;
+
       SkPath path;
       path.incReserve(4);
       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));
 
       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_;
   ArrowType arrow_type_;
+  const int arrow_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBorder);
 };
 
 }  // namespace
 
 namespace internal {
 
 // SystemTrayBubbleView
 
@@ skipping 70 matching lines @@
 void SystemTrayBubbleView::OnMouseEntered(const views::MouseEvent& event) {
   if (host_)
     host_->StopAutoCloseTimer();
 }
 
 void SystemTrayBubbleView::OnMouseExited(const views::MouseEvent& event) {
   if (host_)
     host_->RestartAutoCloseTimer();
 }
 
+// SystemTrayBubble::InitParams
+SystemTrayBubble::InitParams::InitParams(
+    SystemTrayBubble::AnchorType anchor_type)
+    : anchor(NULL),
+      anchor_type(anchor_type),
+      can_activate(false),
+      login_status(ash::user::LOGGED_IN_NONE),
+      arrow_offset(kArrowPaddingFromRight + kArrowWidth / 2) {
+}
+
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
       bubble_view_(NULL),
       bubble_widget_(NULL),
       items_(items),
@@ skipping 19 matching lines @@
     BubbleType bubble_type) {
   DestroyItemViews();
   bubble_view_->RemoveAllChildViews(true);
 
   items_ = items;
   bubble_type_ = bubble_type;
   CreateItemViews(Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
   bubble_widget_->GetContentsView()->Layout();
 }
 
-void SystemTrayBubble::InitView(views::View* anchor,
-                                AnchorType anchor_type,
-                                bool can_activate,
-                                ash::user::LoginStatus login_status) {
+void SystemTrayBubble::InitView(const InitParams& init_params) {
   DCHECK(bubble_view_ == NULL);
-  anchor_type_ = anchor_type;
-  bubble_view_ = new SystemTrayBubbleView(anchor, this, can_activate);
+  anchor_type_ = init_params.anchor_type;
+  bubble_view_ = new SystemTrayBubbleView(
+      init_params.anchor, this, init_params.can_activate);
 
-  CreateItemViews(login_status);
+  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::ArrowType arrow_type;
   if (anchor_type_ == ANCHOR_TYPE_TRAY)
     arrow_type = SystemTrayBubbleBorder::ARROW_TYPE_BOTTOM;
   else
     arrow_type = SystemTrayBubbleBorder::ARROW_TYPE_NONE;
-  bubble_view_->SetBubbleBorder(
-      new SystemTrayBubbleBorder(bubble_view_, arrow_type));
+
+  SystemTrayBubbleBorder* bubble_border = new SystemTrayBubbleBorder(
+      bubble_view_, arrow_type, init_params.arrow_offset);
+  bubble_view_->SetBubbleBorder(bubble_border);
 
   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);
@@ skipping 90 matching lines @@
 }
 
 void SystemTrayBubble::OnWidgetClosing(views::Widget* widget) {
   CHECK_EQ(bubble_widget_, widget);
   bubble_widget_ = NULL;
   tray_->RemoveBubble(this);
 }
 
 }  // namespace internal
 }  // namespace ash