aura: Fix launcher tooltips:

ui/views/bubble/bubble_border_geometric.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_GEOMETRIC_H_
+#define UI_VIEWS_BUBBLE_BUBBLE_BORDER_GEOMETRIC_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 BubbleBorderGeometric : public BubbleBorder {

[sky, 2012/08/03 17:59:25]

Surely there be a better name than this. I would take BubbleBorder2 over this
name.

[msw, 2012/08/03 18:08:26]

Hahaha, sorry Scott, I didn't think it was that bad. - Mike

[varunjain, 2012/08/03 18:22:42]

BubbleBorder2 it is!

+ public:
+  explicit BubbleBorderGeometric(ArrowLocation arrow_location);
+  virtual ~BubbleBorderGeometric();
+
+  // 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_anchor_edge_offset(int anchor_edge_offset) {
+    anchor_edge_offset_ = anchor_edge_offset;
+  }
+
+  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() { return corner_radius_; }

[sky, 2012/08/03 17:59:25]

const (43, 46 and 49)

[varunjain, 2012/08/03 18:22:42]

Done.

+
+  void set_border_size(int border_size) { border_size_ = border_size; }
+  int border_size() { return border_size_; }
+
+  void set_arrow_height(int arrow_height) { arrow_height_ = arrow_height; }
+  int arrow_height() { return arrow_height_; }
+
+  void set_arrow_width(int arrow_width) { arrow_width_ = arrow_width; }
+  int arrow_width() { return arrow_width_; }
+
+  void SetShadow(gfx::ShadowValue shadow);
+
+  // views::BubbleBorder overrides:
+  int border_thickness() 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_;
+
+  // Distance between the tip of the arrow and the anchor view's edge.
+  int anchor_edge_offset_;

[msw, 2012/08/03 18:08:26]

From this new value and its uses, it looks like you're trying to get the
bubble's arrow point to lay within the anchor view's bounds by some amount (or
perhaps moving the bubble further away from the anchor view's bounds).

I've handled this in the past by having BubbleDelegateView implementations
override GetAnchorRect() and inset or outset the rect by the desired amount. Can
you try that approach?

[varunjain, 2012/08/03 18:22:42]

I think it is better to provide the BubbleDelegateView the functionality to
explicitly set the offset rather than having to override GetAnchorRect() every
time. The current BubbleBorder also has this functionality
(override_arrow_offset_).

[msw, 2012/08/03 19:55:46]

To recap offline discussion (really for posterity):

1) I believe override_arrow_offset_ / SetArrowOffset moves the arrow point
alongside the edge of the anchor rect, whereas you wish to move the arrow point
further from (or closer within) the anchor rect bounds. Besides, SetArrowOffset
apparently has no callers, so perhaps that should be deprecated.

2) I propose that you add a "gfx::Insets anchor_inset_;" value and setter/getter
to BubbleDelegateView that is applied to the anchor rect in
BubbleDelegateView::GetAnchorRect().

Here's why: Using a gfx::Insets with gfx::Rect makes more sense than applying a
single "int x" like a gfx::Insets(x, x, x, x) value to the gfx::Rect in arrow
positioning calculations (which increases complexity, cognitive load, and
maintenance costs). Insets have very clearly defined behavior, whereas the old
bubble code used a single int value and applied it incorrectly when the bubble
was flipped (from the top of the anchor rect to the bottom). This will also
allow the several existing GetAnchorRect() overrides that just apply a
gfx::Insets to the anchor view's bounds to use this simpler mechanism (better
code elsewhere, yay!). Finally, this also allows users to apply different values
on each edge (if needed).

[varunjain, 2012/08/03 20:29:26]

Done.

+
+  // 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(BubbleBorderGeometric);
+};
+
+}  // namespace views
+
+#endif  // UI_VIEWS_BUBBLE_BUBBLE_BORDER_GEOMETRIC_H_