aura: Fix launcher tooltips:

1. Refactor out app_list_bubble_border so that it can be used for launcher
tooltip border.
2. UI polish: increase padding, make tooltip single line, reduce maximum
tooltip width.

BUG=133292
TEST=manual

Review URL: https://chromiumcodereview.appspot.com/10834140

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@149987 0039d316-1c4b-4281-b951-d872f2087c98

ash/launcher/launcher_tooltip_manager.cc

@@ -18,6 +18,8 @@
 #include "ui/base/events.h"
 #include "ui/gfx/insets.h"
 #include "ui/views/bubble/bubble_delegate.h"
+#include "ui/views/bubble/bubble_frame_view.h"
+#include "ui/views/bubble/bubble_border_2.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
@@ -25,12 +27,22 @@
 namespace ash {
 namespace internal {
 namespace {
-const int kTooltipMargin = 3;
+const int kTooltipTopBottomMargin = 3;
+const int kTooltipLeftRightMargin = 10;
 const int kTooltipAppearanceDelay = 200;  // msec
+const int kTooltipMinHeight = 29 - 2 * kTooltipTopBottomMargin;
+const SkColor kTooltipTextColor = SkColorSetRGB(22, 22, 22);
 
 // The maximum width of the tooltip bubble.  Borrowed the value from
 // ash/tooltip/tooltip_controller.cc
-const int kTooltipMaxWidth = 400;
+const int kTooltipMaxWidth = 250;
+
+// Bubble border metrics
+const int kArrowHeight = 7;
+const int kArrowWidth = 15;
+const int kShadowWidth = 8;
+// The distance between the arrow tip and edge of the anchor view.
+const int kArrowOffset = 10;
 
 views::BubbleBorder::ArrowLocation GetArrowLocation(ShelfAlignment alignment) {
   switch (alignment) {
@@ -58,11 +70,20 @@ class LauncherTooltipManager::LauncherTooltipBubble
   void Close();
 
  private:
+  // Overridden from views::BubbleDelegateView:
+  virtual gfx::Rect GetBubbleBounds() OVERRIDE;
+
   // views::WidgetDelegate overrides:
   virtual void WindowClosing() OVERRIDE;
 
+  // views::View overrides:
+  virtual gfx::Size GetPreferredSize() OVERRIDE;
+
   LauncherTooltipManager* host_;
   views::Label* label_;
+  views::BubbleBorder2* bubble_border_;
+
+  DISALLOW_COPY_AND_ASSIGN(LauncherTooltipBubble);
 };
 
 LauncherTooltipManager::LauncherTooltipBubble::LauncherTooltipBubble(
@@ -70,12 +91,13 @@ LauncherTooltipManager::LauncherTooltipBubble::LauncherTooltipBubble(
     views::BubbleBorder::ArrowLocation arrow_location,
     LauncherTooltipManager* host)
     : views::BubbleDelegateView(anchor, arrow_location),
-      host_(host) {
+      host_(host),
+      bubble_border_(NULL) {
   set_close_on_esc(false);
   set_close_on_deactivate(false);
   set_use_focusless(true);
-  set_margins(gfx::Insets(kTooltipMargin, kTooltipMargin, kTooltipMargin,
-                          kTooltipMargin));
+  set_margins(gfx::Insets(kTooltipTopBottomMargin, kTooltipLeftRightMargin,
+                          kTooltipTopBottomMargin, kTooltipLeftRightMargin));
   SetLayoutManager(new views::FillLayout());
   // The anchor may not have the widget in tests.
   if (anchor->GetWidget() && anchor->GetWidget()->GetNativeView()) {
@@ -86,14 +108,22 @@ LauncherTooltipManager::LauncherTooltipBubble::LauncherTooltipBubble(
   }
   label_ = new views::Label;
   label_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+  label_->SetEnabledColor(kTooltipTextColor);
   AddChildView(label_);
+  views::BubbleDelegateView::CreateBubble(this);
+  bubble_border_ = new views::BubbleBorder2(views::BubbleBorder::BOTTOM_RIGHT);
+  bubble_border_->SetShadow(gfx::ShadowValue(
+      gfx::Point(0, 5), kShadowWidth, SkColorSetARGB(0x72, 0, 0, 0)));
+  bubble_border_->set_arrow_width(kArrowWidth);
+  bubble_border_->set_arrow_height(kArrowHeight);
+  set_anchor_insets(gfx::Insets(kArrowOffset, kArrowOffset, kArrowOffset,
+      kArrowOffset));
+  GetBubbleFrameView()->SetBubbleBorder(bubble_border_);
 }
 
 void LauncherTooltipManager::LauncherTooltipBubble::SetText(
     const string16& text) {
   label_->SetText(text);
-  label_->SetMultiLine(true);
-  label_->SizeToFit(kTooltipMaxWidth);
   SizeToContents();
 }
 
@@ -104,12 +134,43 @@ void LauncherTooltipManager::LauncherTooltipBubble::Close() {
   }
 }
 
+gfx::Rect LauncherTooltipManager::LauncherTooltipBubble::GetBubbleBounds() {
+  // This happens before replacing the default border.
+  if (!bubble_border_)
+    return views::BubbleDelegateView::GetBubbleBounds();
+
+  const gfx::Rect anchor_rect = GetAnchorRect();
+  gfx::Rect bubble_rect = GetBubbleFrameView()->GetUpdatedWindowBounds(
+      anchor_rect,
+      GetPreferredSize(),
+      false /* try_mirroring_arrow */);
+
+  const gfx::Point old_offset = bubble_border_->offset();
+  bubble_rect = bubble_border_->ComputeOffsetAndUpdateBubbleRect(bubble_rect,
+      anchor_rect);
+
+  // Repaints border if arrow offset is changed.
+  if (bubble_border_->offset() != old_offset)
+    GetBubbleFrameView()->SchedulePaint();
+
+  return bubble_rect;
+}
+
 void LauncherTooltipManager::LauncherTooltipBubble::WindowClosing() {
   views::BubbleDelegateView::WindowClosing();
   if (host_)
     host_->OnBubbleClosed(this);
 }
 
+gfx::Size LauncherTooltipManager::LauncherTooltipBubble::GetPreferredSize() {
+  gfx::Size pref_size = views::BubbleDelegateView::GetPreferredSize();
+  if (pref_size.height() < kTooltipMinHeight)
+    pref_size.set_height(kTooltipMinHeight);
+  if (pref_size.width() > kTooltipMaxWidth)
+    pref_size.set_width(kTooltipMaxWidth);
+  return pref_size;
+}
+
 LauncherTooltipManager::LauncherTooltipManager(
     ShelfAlignment alignment,
     ShelfLayoutManager* shelf_layout_manager,
@@ -339,7 +400,6 @@ void LauncherTooltipManager::CreateBubble(views::View* anchor,
   text_ = text;
   view_ = new LauncherTooltipBubble(
       anchor, GetArrowLocation(alignment_), this);
-  views::BubbleDelegateView::CreateBubble(view_);
   widget_ = view_->GetWidget();
   view_->SetText(text_);
 

ui/app_list/app_list_bubble_border.h

@@ -7,52 +7,28 @@
 
 #include "base/basictypes.h"
 #include "ui/gfx/shadow_value.h"
-#include "ui/views/bubble/bubble_border.h"
+#include "ui/views/bubble/bubble_border_2.h"
 
 namespace app_list {
 
 // A class to paint bubble border and background.
-class AppListBubbleBorder : public views::BubbleBorder {
+class AppListBubbleBorder : public views::BubbleBorder2 {
  public:
   AppListBubbleBorder(views::View* app_list_view,
                       views::View* search_box_view);
   virtual ~AppListBubbleBorder();
 
-  bool ArrowAtTopOrBottom() const;
-  bool ArrowOnLeftOrRight() const;
-
-  void GetMask(const gfx::Rect& bounds, gfx::Path* mask) const;
-
-  void set_offset(const gfx::Point& offset) { offset_ = offset; }
-  const gfx::Point& offset() const { return offset_; }
-
  private:
-  // Gets arrow offset based on arrow location and |offset_|.
-  int GetArrowOffset() const;
-
+  // views::ImagelessBubbleBorder overrides:
   void PaintBackground(gfx::Canvas* canvas,
                        const gfx::Rect& bounds) const;
 
-  // views::BubbleBorder overrides:
-  virtual void GetInsets(gfx::Insets* insets) const OVERRIDE;
-  virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
-                              const gfx::Size& contents_size) const OVERRIDE;
-
-  // views::Border overrides:
-  virtual void Paint(const views::View& view,
-                     gfx::Canvas* canvas) const OVERRIDE;
-
   // AppListView hosted inside this bubble.
   const views::View* app_list_view_;  // Owned by views hierarchy.
 
   // Children view of AppListView that needs to paint background.
   const views::View* search_box_view_;  // Owned by views hierarchy.
 
-  // Offset in pixels relative the default middle position.
-  gfx::Point offset_;
-
-  gfx::ShadowValues shadows_;
-
   DISALLOW_COPY_AND_ASSIGN(AppListBubbleBorder);
 };
 

ui/app_list/app_list_view.cc

@@ -13,7 +13,6 @@
 #include "ui/app_list/search_box_model.h"
 #include "ui/app_list/search_box_view.h"
 #include "ui/gfx/insets.h"
-#include "ui/gfx/screen.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/layout/box_layout.h"
@@ -26,6 +25,9 @@ namespace {
 // Inner padding space in pixels of bubble contents.
 const int kInnerPadding = 1;
 
+// The distance between the arrow tip and edge of the anchor view.
+const int kArrowOffset = 10;
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -68,6 +70,8 @@ void AppListView::InitAsBubble(
   set_move_with_anchor(true);
   set_parent_window(parent);
   set_close_on_deactivate(false);
+  set_anchor_insets(gfx::Insets(kArrowOffset, kArrowOffset, kArrowOffset,
+      kArrowOffset));
   views::BubbleDelegateView::CreateBubble(this);
 
   // Resets default background since AppListBubbleBorder paints background.
@@ -152,36 +156,15 @@ gfx::Rect AppListView::GetBubbleBounds() {
   if (!bubble_border_)
     return views::BubbleDelegateView::GetBubbleBounds();
 
-  const gfx::Point old_offset = bubble_border_->offset();
   const gfx::Rect anchor_rect = GetAnchorRect();
-
-  bubble_border_->set_offset(gfx::Point());
   gfx::Rect bubble_rect = GetBubbleFrameView()->GetUpdatedWindowBounds(
       anchor_rect,
       GetPreferredSize(),
       false /* try_mirroring_arrow */);
 
-  gfx::Rect monitor_rect = gfx::Screen::GetDisplayNearestPoint(
-      anchor_rect.CenterPoint()).work_area();
-  if (monitor_rect.IsEmpty() || monitor_rect.Contains(bubble_rect))
-    return bubble_rect;
-
-  gfx::Point offset;
-
-  if (bubble_border_->ArrowAtTopOrBottom()) {
-    if (bubble_rect.x() < monitor_rect.x())
-      offset.set_x(monitor_rect.x() - bubble_rect.x());
-    else if (bubble_rect.right() > monitor_rect.right())
-      offset.set_x(monitor_rect.right() - bubble_rect.right());
-  } else if (bubble_border_->ArrowOnLeftOrRight()) {
-    if (bubble_rect.y() < monitor_rect.y())
-      offset.set_y(monitor_rect.y() - bubble_rect.y());
-    else if (bubble_rect.bottom() > monitor_rect.bottom())
-      offset.set_y(monitor_rect.bottom() - bubble_rect.bottom());
-  }
-
-  bubble_rect.Offset(offset);
-  bubble_border_->set_offset(offset);
+  const gfx::Point old_offset = bubble_border_->offset();
+  bubble_rect = bubble_border_->ComputeOffsetAndUpdateBubbleRect(bubble_rect,
+      anchor_rect);
 
   // Repaints border if arrow offset is changed.
   if (bubble_border_->offset() != old_offset)

ui/views/bubble/bubble_border.cc

@@ -212,7 +212,7 @@ void BubbleBorder::GetInsetsForArrowLocation(gfx::Insets* insets,
   insets->Set(top, left, bottom, right);
 }
 
-int BubbleBorder::border_thickness() const {
+int BubbleBorder::GetBorderThickness() const {
   return images_->border_thickness;
 }
 
@@ -505,7 +505,7 @@ void BubbleBackground::Paint(gfx::Canvas* canvas, views::View* view) const {
   paint.setColor(border_->background_color());
   SkPath path;
   gfx::Rect bounds(view->GetContentsBounds());
-  bounds.Inset(-border_->border_thickness(), -border_->border_thickness());
+  bounds.Inset(-border_->GetBorderThickness(), -border_->GetBorderThickness());
   SkScalar radius = SkIntToScalar(BubbleBorder::GetCornerRadius());
   path.addRoundRect(gfx::RectToSkRect(bounds), radius, radius);
   canvas->DrawPath(path, paint);

ui/views/bubble/bubble_border.h

@@ -118,7 +118,7 @@ class VIEWS_EXPORT BubbleBorder : public Border {
   virtual void GetInsets(gfx::Insets* insets) const OVERRIDE;
 
   // How many pixels the bubble border is from the edge of the images.
-  int border_thickness() const;
+  virtual int GetBorderThickness() const;
 
  protected:
   virtual ~BubbleBorder();
@@ -126,7 +126,7 @@ class VIEWS_EXPORT BubbleBorder : public Border {
   // Calculates the insets for a specific arrow location. Normally called from
   // GetInsets(arrow_location()), but may be called by specialized BubbleBorder
   // implementations.
-  void GetInsetsForArrowLocation(gfx::Insets* insets,
+  virtual void GetInsetsForArrowLocation(gfx::Insets* insets,
                                          ArrowLocation arrow_loc) const;
 
  private:

ui/views/bubble/bubble_border_2.h

+// 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.
+
+#ifndef UI_VIEWS_BUBBLE_BUBBLE_BORDER_2_H_
+#define UI_VIEWS_BUBBLE_BUBBLE_BORDER_2_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "ui/gfx/shadow_value.h"
+#include "ui/views/bubble/bubble_border.h"
+
+namespace views {
+
+// A BubbleBorder rendered with Skia drawing commands instead of images.
+class VIEWS_EXPORT BubbleBorder2 : public BubbleBorder {
+ public:
+  explicit BubbleBorder2(ArrowLocation arrow_location);
+  virtual ~BubbleBorder2();
+
+  // Given the |bubble_rect| that this border encloses, and the bounds of the
+  // anchor view |anchor_view_rect|, compute the right offset to place the
+  // arrow at shifting the |bubble_rect| to fit inside the display area if
+  // needed. Returns the shifted |bubble_rect|.
+  gfx::Rect ComputeOffsetAndUpdateBubbleRect(gfx::Rect bubble_rect,
+                                             const gfx::Rect& anchor_view_rect);
+
+  // Returns the path in |mask| that would be created if this border were to be
+  // applied to the rect specified by |bounds|.
+  void GetMask(const gfx::Rect& bounds, gfx::Path* mask) const;
+
+  void set_offset(const gfx::Point& offset) { offset_ = offset; }
+  const gfx::Point& offset() const { return offset_; }
+
+  void set_corner_radius(int corner_radius) { corner_radius_ = corner_radius; }
+  int corner_radius() const { return corner_radius_; }
+
+  void set_border_size(int border_size) { border_size_ = border_size; }
+  int border_size() const { return border_size_; }
+
+  void set_arrow_height(int arrow_height) { arrow_height_ = arrow_height; }
+  int arrow_height() const { return arrow_height_; }
+
+  void set_arrow_width(int arrow_width) { arrow_width_ = arrow_width; }
+  int arrow_width() const { return arrow_width_; }
+
+  void SetShadow(gfx::ShadowValue shadow);
+
+  // views::BubbleBorder overrides:
+  int GetBorderThickness() const OVERRIDE;
+
+ protected:
+  void PaintBackground(gfx::Canvas* canvas,
+                       const gfx::Rect& bounds) const;
+
+ private:
+  // Gets arrow offset based on arrow location and |offset_|.
+  int GetArrowOffset() const;
+
+  // views::BubbleBorder overrides:
+  virtual void GetInsets(gfx::Insets* insets) const OVERRIDE;
+  virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
+                              const gfx::Size& contents_size) const OVERRIDE;
+  void GetInsetsForArrowLocation(gfx::Insets* insets,
+                                 ArrowLocation arrow_loc) const OVERRIDE;
+
+  // views::Border overrides:
+  virtual void Paint(const View& view,
+                     gfx::Canvas* canvas) const OVERRIDE;
+
+  int corner_radius_;
+  int border_size_;
+  int arrow_height_;
+  int arrow_width_;
+  SkColor background_color_;
+  SkColor border_color_;
+
+  // Offset in pixels by which the arrow is shifted relative the default middle
+  // position. If the arrow is placed horizontally (at top or bottom), the |x_|
+  // component of |offset_| specifies the offset, else, the |y_| component.
+  gfx::Point offset_;
+
+  gfx::ShadowValues shadows_;
+
+  DISALLOW_COPY_AND_ASSIGN(BubbleBorder2);
+};
+
+}  // namespace views
+
+#endif  // UI_VIEWS_BUBBLE_BUBBLE_BORDER_2_H_

ui/views/bubble/bubble_delegate.cc

@@ -230,7 +230,11 @@ void BubbleDelegateView::OnWidgetMoved(Widget* widget) {
 }
 
 gfx::Rect BubbleDelegateView::GetAnchorRect() {
-  return anchor_view() ? anchor_view()->GetBoundsInScreen() : gfx::Rect();
+  if (!anchor_view())
+    return gfx::Rect();
+  gfx::Rect anchor_bounds = anchor_view()->GetBoundsInScreen();
+  anchor_bounds.Inset(anchor_insets_);
+  return anchor_bounds;
 }
 
 void BubbleDelegateView::Show() {

ui/views/bubble/bubble_delegate.h

@@ -72,6 +72,9 @@ class VIEWS_EXPORT BubbleDelegateView : public WidgetDelegateView,
   const gfx::Insets& margins() const { return margins_; }
   void set_margins(const gfx::Insets& margins) { margins_ = margins; }
 
+  void set_anchor_insets(const gfx::Insets& insets) { anchor_insets_ = insets; }
+  const gfx::Insets& anchor_insets() const { return anchor_insets_; }
+
   gfx::NativeView parent_window() const { return parent_window_; }
   void set_parent_window(gfx::NativeView window) { parent_window_ = window; }
 
@@ -157,6 +160,9 @@ class VIEWS_EXPORT BubbleDelegateView : public WidgetDelegateView,
   // The margins between the content and the inside of the border.
   gfx::Insets margins_;
 
+  // Insets applied to the |anchor_view_| bounds.
+  gfx::Insets anchor_insets_;
+
   // Original opacity of the bubble.
   int original_opacity_;
 

ui/views/bubble/bubble_frame_view.cc

@@ -91,6 +91,9 @@ gfx::Rect BubbleFrameView::GetUpdatedWindowBounds(const gfx::Rect& anchor_rect,
 void BubbleFrameView::SetBubbleBorder(BubbleBorder* border) {
   bubble_border_ = border;
   set_border(bubble_border_);
+
+  // Update the background, which relies on the border.
+  set_background(new views::BubbleBackground(border));
 }
 
 gfx::Rect BubbleFrameView::GetMonitorBounds(const gfx::Rect& rect) {

ui/views/views.gyp

@@ -62,6 +62,8 @@
         'bubble/bubble_delegate.h',
         'bubble/bubble_frame_view.cc',
         'bubble/bubble_frame_view.h',
+        'bubble/bubble_border_2.cc',
+        'bubble/bubble_border_2.h',
         'button_drag_utils.cc',
         'button_drag_utils.h',
         'color_chooser/color_chooser_listener.h',