Consolidate bubble border code.

ui/views/bubble/bubble_border.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_H_
 #define UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "ui/views/background.h"
@@ skipping 21 matching lines @@
     LEFT_TOP     = 4,
     RIGHT_TOP    = 5,
     LEFT_BOTTOM  = 6,
     RIGHT_BOTTOM = 7,
     NONE  = 8,  // No arrow. Positioned under the supplied rect.
     FLOAT = 9   // No arrow. Centered over the supplied rect.
   };
 
   enum Shadow {
     SHADOW    = 0,
-    NO_SHADOW = 1
+    NO_SHADOW,
+#if defined(USE_AURA)
+    BIG_SHADOW,
+    SMALL_SHADOW,
+#endif
+    SHADOW_COUNT

[msw, 2012/09/18 19:33:42]

nit: add a comma (same for ArrowLocation if you don't mind).

[xiyuan, 2012/09/19 18:20:09]

Done.

   };
 
   // The position of the bubble in relation to the anchor.
   enum BubbleAlignment {
     // The tip of the arrow points to the middle of the anchor.
     ALIGN_ARROW_TO_MID_ANCHOR,
     // The edge nearest to the arrow is lined up with the edge of the anchor.
     ALIGN_EDGE_TO_ANCHOR_EDGE
   };
 
   BubbleBorder(ArrowLocation arrow_location, Shadow shadow);
 
   // Returns the radius of the corner of the border.
+  // TODO(xiyuan): Get rid of this since it's part of BorderImages now?

[msw, 2012/09/18 19:33:42]

Yeah, GetCornerRadius and GetBorderCornerRadius are redundant.
Did you mean to address this now or later? (later is ok w/me)

[xiyuan, 2012/09/19 18:20:09]

I'll do it later in a clean up CL. Right now, this function is used like a theme
param and used in places that are not related to bubble at all, such as omnibox
popup and balloon view. We probably want this const to defined somewhere else
instead of here.

[msw, 2012/09/19 20:12:31]

sgtm

   static int GetCornerRadius() {
     // We can't safely calculate a border radius by comparing the sizes of the
     // side and corner images, because either may have been extended in various
     // directions in order to do more subtle dropshadow fading or other effects.
     // So we hardcode the most accurate value.
     return 4;
   }
 
   // Sets the location for the arrow.
   void set_arrow_location(ArrowLocation loc) { arrow_location_ = loc; }
@@ skipping 28 matching lines @@
   }
 
   // Sets the background color for the arrow body.  This is irrelevant if you do
   // not also set the arrow location to something other than NONE.
   void set_background_color(SkColor color) { background_color_ = color; }
   SkColor background_color() const { return background_color_; }
 
   void set_client_bounds(const gfx::Rect& bounds) { client_bounds_ = bounds; }
   const gfx::Rect& client_bounds() const { return client_bounds_; }
 
+  void set_relative_arrow_offset(int relative_arrow_offset) {

[msw, 2012/09/18 19:33:42]

nit: fits on one line if you s/relative_arrow_offset/offset/

[xiyuan, 2012/09/19 18:20:09]

Done.

+    relative_arrow_offset_ = relative_arrow_offset;
+  }
+  int relative_arrow_offset() const { return relative_arrow_offset_; }
+
+  void set_center_arrow(bool center_arrow) { center_arrow_ = center_arrow; }
+  bool center_arrow() const { return center_arrow_; }
+
   // For borders with an arrow, gives the desired bounds (in screen coordinates)
   // given the rect to point to and the size of the contained contents.  This
   // depends on the arrow location, so if you change that, you should call this
   // again to find out the new coordinates.
   virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
                               const gfx::Size& contents_size) const;
 
+  // Returns the corner radius of current image set.

[msw, 2012/09/18 19:33:42]

nit: "*the* current"

[xiyuan, 2012/09/19 18:20:09]

Done.

+  int GetBorderCornerRadius() const;
+
   // Sets a fixed offset for the arrow from the beginning of corresponding edge.
   // The arrow will still point to the same location but the bubble will shift
-  // location to make that happen. Returns actuall arrow offset, in case of
-  // overflow it differ from desired.
+  // location to make that happen. Returns actual arrow offset, in case of
+  // overflow it differs from desired.
   int SetArrowOffset(int offset, const gfx::Size& contents_size);
 
   // Overridden from Border:
   virtual void GetInsets(gfx::Insets* insets) const OVERRIDE;
 
   // How many pixels the bubble border is from the edge of the images.
   virtual int GetBorderThickness() const;
 
  protected:
   virtual ~BubbleBorder();
@@ skipping 19 matching lines @@
                          gfx::ImageSkia* edge,
                          gfx::ImageSkia* arrow,
                          int start_x,
                          int start_y,
                          int before_arrow,
                          int after_arrow,
                          int offset) const;
 
   void DrawArrowInterior(gfx::Canvas* canvas, float tip_x, float tip_y) const;
 
+  // Ensures that |arrow_offset| is in valid range so that border images are
+  // drawn correctly.
+  int SanitizeArrowOffset(int arrow_offset, const gfx::Size& border_size) const;
+
+  // Calculates the arrow offset to use.
+  int CalculateArrowOffset(const gfx::Size& border_size) const;
+
   // Border graphics.
   struct BorderImages* images_;
 
   // Image bundles.
-  static struct BorderImages* normal_images_;
-  static struct BorderImages* shadow_images_;
+  static struct BorderImages* border_images_[SHADOW_COUNT];
 
   // Minimal offset of the arrow from the closet edge of bounding rect.
   int arrow_offset_;
 
   // If specified, overrides the pre-calculated |arrow_offset_| of the arrow.
   int override_arrow_offset_;
 
+  // Relative offset to move current arrow. It is used for move bubble relative

[msw, 2012/09/18 19:33:42]

nit: grammar "to move the" twice.

[xiyuan, 2012/09/19 18:20:09]

Done.

+  // to its default position when it is off screen.
+  int relative_arrow_offset_;

[msw, 2012/09/18 19:33:42]

Instead of adding a new offset (in addition to |arrow_offset_| and
|override_arrow_offset_|), why not set |override_arrow_offset_| in
BubbleFrameView when the bubble is offscreen?

[xiyuan, 2012/09/19 18:20:09]

Initially my concern is that if we set |override_arrow_offset_|, we lose it and
would not be able to revert to original value.

e.g. if user sets |override_arrow_offset_| to some value and the bubble
initially could not fit on screen, so we change |override_arrow_offset_|. Then,
things change (anchor moved, screen size changed etc) and the bubble could now
fit. And we would not be able to restore to user set value.

Then I checked that the only user of override_arrow_offset_ is in launcher
Overflow bubble code which does offscreen adjustment by itself. So the concern
is not valid, at least not with the current trunk code.

Removed as suggested.

[msw, 2012/09/19 20:12:31]

Great! Thanks for being thorough!

+
   ArrowLocation arrow_location_;
   BubbleAlignment alignment_;
   SkColor background_color_;
 
   // The client/content bounds; must be clipped from the background on Windows.
   // TODO(msw): Clean this up when Windows native controls are no longer needed.
   gfx::Rect client_bounds_;
 
+  // If true (default is false) and |override_arrow_offset_| is not specified,
+  // use arrow edge's center point as default arrow offset.
+  bool center_arrow_;

[msw, 2012/09/18 19:33:42]

This state should be merged into the ArrowLocation enum.
TOP_CENTER is clearer than TOP_[LEFT|RIGHT] + center_arrow.

[xiyuan, 2012/09/19 18:20:09]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(BubbleBorder);
 };
 
 // A Background that clips itself to the specified BubbleBorder and uses
 // the background color of the BubbleBorder.
 class VIEWS_EXPORT BubbleBackground : public Background {
  public:
   explicit BubbleBackground(BubbleBorder* border) : border_(border) {}
 
   // Overridden from Background:
   virtual void Paint(gfx::Canvas* canvas, View* view) const OVERRIDE;
 
  private:
   BubbleBorder* border_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleBackground);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_