Fix padding in location bar bubbles to match specs on bug.

chrome/browser/ui/views/location_bar/icon_label_bubble_view.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 "chrome/browser/ui/views/location_bar/icon_label_bubble_view.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/views/location_bar/background_with_1_px_border.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
+#include "ui/gfx/image/image_util.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/animation/ink_drop_hover.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/painter.h"
 
 namespace {
 
 SkColor CalculateImageColor(gfx::ImageSkia* image) {
   // We grab the color of the middle pixel of the image, which we treat as
   // the representative color of the entire image (reasonable, given the current
   // appearance of these assets).
   const SkBitmap& bitmap(image->GetRepresentation(1.0f).sk_bitmap());
   SkAutoLockPixels pixel_lock(bitmap);
   return bitmap.getColor(bitmap.width() / 2, bitmap.height() / 2);
 }
 
 }  // namespace
 
 IconLabelBubbleView::IconLabelBubbleView(int contained_image,
                                          const gfx::FontList& font_list,
                                          SkColor parent_background_color,
                                          bool elide_in_middle)
     : background_painter_(nullptr),
       image_(new views::ImageView()),
       label_(new views::Label(base::string16(), font_list)),
+      builtin_leading_padding_(0),
+      builtin_trailing_padding_(0),
       is_extension_icon_(false),
       parent_background_color_(parent_background_color) {
   if (contained_image) {
     image_->SetImage(
         ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
             contained_image));
   }
 
   // Disable separate hit testing for |image_|.  This prevents views treating
   // |image_| as a separate mouse hover region from |this|.
@@ skipping 38 matching lines @@
   should_show_background_ = false;
   SetLabelBackgroundColor(SK_ColorTRANSPARENT);
 }
 
 void IconLabelBubbleView::SetLabel(const base::string16& label) {
   label_->SetText(label);
 }
 
 void IconLabelBubbleView::SetImage(const gfx::ImageSkia& image_skia) {
   image_->SetImage(image_skia);
+
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    gfx::GetVisibleMargins(image_skia, &builtin_leading_padding_,
+                           &builtin_trailing_padding_);
+    if (base::i18n::IsRTL())
+      std::swap(builtin_leading_padding_, builtin_trailing_padding_);
+  }
 }
 
 bool IconLabelBubbleView::ShouldShowBackground() const {
   return should_show_background_;
 }
 
 double IconLabelBubbleView::WidthMultiplier() const {
   return 1.0;
 }
 
 bool IconLabelBubbleView::IsShrinking() const {
   return false;
 }
 
-int IconLabelBubbleView::GetImageAndPaddingWidth() const {
-  return image_->GetPreferredSize().width() + GetInternalSpacing();
-}
-
 gfx::Size IconLabelBubbleView::GetPreferredSize() const {
   // Height will be ignored by the LocationBarView.
   return GetSizeForLabelWidth(label_->GetPreferredSize().width());
 }
 
 void IconLabelBubbleView::Layout() {
   // Compute the image bounds.  In non-MD, the leading padding depends on
   // whether this is an extension icon, since extension icons and
   // Chrome-provided icons are different sizes.  In MD, these sizes are the
   // same, so it's not necessary to handle the two types differently.
@@ skipping 24 matching lines @@
   // be enough room to show the image at all.
   const int image_width =
       std::min(image_preferred_width,
                std::max(0, width() - image_x - bubble_trailing_padding));
   image_->SetBounds(image_x, 0, image_width, height());
 
   // Compute the label bounds.  The label gets whatever size is left over after
   // accounting for the preferred image width and padding amounts.  Note that if
   // the label has zero size it doesn't actually matter what we compute its X
   // value to be, since it won't be visible.
-  const int label_x = image_x + GetImageAndPaddingWidth();
+  const int label_x = image_x + image_width + GetInternalSpacing();
   const int label_width =
       std::max(0, width() - label_x - bubble_trailing_padding);
   label_->SetBounds(label_x, 0, label_width, height());
 }
 
 void IconLabelBubbleView::OnNativeThemeChanged(
     const ui::NativeTheme* native_theme) {
   label_->SetEnabledColor(GetTextColor());
 
   if (!ui::MaterialDesignController::IsModeMaterial())
@@ skipping 43 matching lines @@
   // is necessary to animate |total_width| even when the background is hidden
   // as long as the animation is still shrinking.
   if (ShouldShowBackground() || shrinking) {
     // |multiplier| grows from zero to one, stays equal to one and then shrinks
     // to zero again. The view width should correspondingly grow from zero to
     // fully showing both label and icon, stay there, then shrink to just large
     // enough to show the icon. We don't want to shrink all the way back to
     // zero, since this would mean the view would completely disappear and then
     // pop back to an icon after the animation finishes.
     const int max_width = MinimumWidthForImageWithBackgroundShown() +
-        GetInternalSpacing() + label_width;
+                          GetInternalSpacing() + label_width;
     const int current_width = WidthMultiplier() * max_width;
-    size.set_width(
-        shrinking ? std::max(current_width, size.width()) : current_width);
+    size.set_width(shrinking ? std::max(current_width, size.width())
+                             : current_width);
   }
   return size;
 }
 
 int IconLabelBubbleView::MinimumWidthForImageWithBackgroundShown() const {
   return GetOuterPadding(true) + image_->GetPreferredSize().width() +
          GetOuterPadding(false);
 }
 
 void IconLabelBubbleView::SetLabelBackgroundColor(
     SkColor chip_background_color) {
   // The background images are painted atop |parent_background_color_|.
   // Alpha-blend |chip_background_color| with |parent_background_color_| to
   // determine the actual color the label text will sit atop.
   // Tricky bit: We alpha blend an opaque version of |chip_background_color|
   // against |parent_background_color_| using the original image grid color's
   // alpha. This is because AlphaBlend(a, b, 255) always returns |a| unchanged
   // even if |a| is a color with non-255 alpha.
   label_->SetBackgroundColor(color_utils::AlphaBlend(
       SkColorSetA(chip_background_color, 255), GetParentBackgroundColor(),
       SkColorGetA(chip_background_color)));
 }
 
 int IconLabelBubbleView::GetOuterPadding(bool leading) const {
   if (ui::MaterialDesignController::IsModeMaterial()) {
     // Leading and trailing padding are equal.

[varkha, 2016/03/30 05:21:58]

nit: The comment seems to be no longer accurate.

[Peter Kasting, 2016/03/30 05:33:37]

The intent of the comment is to say that the apparent leading and trailing
padding are equal.  I could probably expand the wording to make that more
obvious.

[Peter Kasting, 2016/03/30 05:55:02]

Done.

-    return GetLayoutConstant(ICON_LABEL_VIEW_TRAILING_PADDING);
+    return GetLayoutConstant(ICON_LABEL_VIEW_TRAILING_PADDING) -
+           (leading ? builtin_leading_padding_ : 0);
   }
 
   return GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING) -
          GetLayoutConstant(LOCATION_BAR_BUBBLE_HORIZONTAL_PADDING) +
          (leading ? 0 : GetLayoutConstant(ICON_LABEL_VIEW_TRAILING_PADDING));
 }
 
 int IconLabelBubbleView::GetInternalSpacing() const {
-  return image_->GetPreferredSize().IsEmpty() ?
-      0 : GetLayoutConstant(ICON_LABEL_VIEW_INTERNAL_SPACING);
+  return image_->GetPreferredSize().IsEmpty()
+             ? 0
+             : (GetLayoutConstant(ICON_LABEL_VIEW_INTERNAL_SPACING) -
+                builtin_trailing_padding_);
 }
 
 const char* IconLabelBubbleView::GetClassName() const {
   return "IconLabelBubbleView";
 }
 
 void IconLabelBubbleView::OnPaint(gfx::Canvas* canvas) {
   if (!ShouldShowBackground())
     return;
   if (background_painter_) {
     views::Painter::PaintPainterAt(canvas, background_painter_.get(),
                                    GetContentsBounds());
   }
   if (background())
     background()->Paint(canvas, this);
 }