Views: Don't add insets for views::Link focus rings under MD.

ui/views/controls/styled_label.cc

 // Copyright 2013 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 "ui/views/controls/styled_label.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <vector>
 
 #include "base/strings/string_util.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/styled_label_listener.h"
 
 namespace views {
 
-
 // Helpers --------------------------------------------------------------------
 
 namespace {
 
+gfx::Insets FocusBorderInsets(const Label& label) {
+  // StyledLabel never adds a border, so the only Insets added are for the
+  // possible focus ring.
+  DCHECK(label.View::GetInsets().IsEmpty());
+  return label.GetInsets();
+}
+
 // Calculates the height of a line of text. Currently returns the height of
 // a label.
 int CalculateLineHeight(const gfx::FontList& font_list) {
   Label label;
   label.SetFontList(font_list);
   return label.GetPreferredSize().height();
 }
 
 std::unique_ptr<Label> CreateLabelRange(
     const base::string16& text,
     const gfx::FontList& font_list,
     const StyledLabel::RangeStyleInfo& style_info,
     views::LinkListener* link_listener) {
   std::unique_ptr<Label> result;
 
   if (style_info.is_link) {
     Link* link = new Link(text);
     link->set_listener(link_listener);
-    link->SetUnderline((style_info.font_style & gfx::Font::UNDERLINE) != 0);
+
+    // StyledLabel makes assumptions about how to inset the entire View based on
+    // the default focus style: If focus rings are not the default, nothing is
+    // inset. So an individual range can't deviate from that.
+    if (Link::GetDefaultFocusStyle() == Link::FocusStyle::UNDERLINE) {
+      // Nothing should (and nothing does) request underlines for links with MD.
+      DCHECK_EQ(0, style_info.font_style & gfx::Font::UNDERLINE);
+      link->SetUnderline(false);  // Override what Link::Init() does.
+    } else {
+      link->SetUnderline((style_info.font_style & gfx::Font::UNDERLINE) != 0);
+    }
+
     result.reset(link);
   } else {
     result.reset(new Label(text));
   }
 
   if (style_info.color != SK_ColorTRANSPARENT)
     result->SetEnabledColor(style_info.color);
   result->SetFontList(font_list);
 
   if (!style_info.tooltip.empty())
     result->SetTooltipText(style_info.tooltip);
   if (style_info.font_style != gfx::Font::NORMAL ||
       style_info.weight != gfx::Font::Weight::NORMAL) {
     result->SetFontList(result->font_list().Derive(0, style_info.font_style,
                                                    style_info.weight));
   }
 
   return result;
 }
 
 }  // namespace
 
-
 // StyledLabel::RangeStyleInfo ------------------------------------------------
 
 StyledLabel::RangeStyleInfo::RangeStyleInfo()
     : font_style(gfx::Font::NORMAL),
       weight(gfx::Font::Weight::NORMAL),
       color(SK_ColorTRANSPARENT),
       disable_line_wrapping(false),
       is_link(false) {}
 
 StyledLabel::RangeStyleInfo::~RangeStyleInfo() {}
@@ skipping 92 matching lines @@
 
   SetSize(CalculateAndDoLayout(max_width, true));
 }
 
 const char* StyledLabel::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Insets StyledLabel::GetInsets() const {
   gfx::Insets insets = View::GetInsets();
+  if (Link::GetDefaultFocusStyle() != Link::FocusStyle::RING)
+    return insets;
 
   // We need a focus border iff we contain a link that will have a focus border.
   // That in turn will be true only if the link is non-empty.
   for (StyleRanges::const_iterator i(style_ranges_.begin());
         i != style_ranges_.end(); ++i) {
     if (i->style_info.is_link && !i->range.is_empty()) {
-      const gfx::Insets focus_border_padding(
-          Label::kFocusBorderPadding, Label::kFocusBorderPadding,
-          Label::kFocusBorderPadding, Label::kFocusBorderPadding);
-      insets += focus_border_padding;
+      insets += gfx::Insets(Link::kFocusBorderPadding);
       break;
     }
   }
 
   return insets;
 }
 
 gfx::Size StyledLabel::GetPreferredSize() const {
   return calculated_size_;
 }
@@ skipping 142 matching lines @@
       // This chunk is normal text.
       if (position + chunk.size() > range.start())
         chunk = chunk.substr(0, range.start() - position);
       label = CreateLabelRange(chunk, font_list_, default_style_info_, this);
     }
 
     if (displayed_on_background_color_set_)
       label->SetBackgroundColor(displayed_on_background_color_);
     label->SetAutoColorReadabilityEnabled(auto_color_readability_enabled_);
 
-    // Calculate the size of the optional focus border, and overlap by that
-    // amount. Otherwise, "<a>link</a>," will render as "link ,".
-    gfx::Insets focus_border_insets(label->GetInsets());
-    focus_border_insets -= label->View::GetInsets();
     const gfx::Size view_size = label->GetPreferredSize();
     const gfx::Insets insets = GetInsets();
-    label->SetBoundsRect(gfx::Rect(
-        gfx::Point(
-            insets.left() + x - focus_border_insets.left(),
-            insets.top() + line * line_height - focus_border_insets.top()),
-        view_size));
-    x += view_size.width() - focus_border_insets.width();
+    gfx::Point view_origin(insets.left() + x,
+                           insets.top() + line * line_height);
+    if (Link::GetDefaultFocusStyle() == Link::FocusStyle::RING) {
+      // Calculate the size of the optional focus border, and overlap by that
+      // amount. Otherwise, "<a>link</a>," will render as "link ,".
+      const gfx::Insets focus_border_insets = FocusBorderInsets(*label);
+      view_origin.Offset(-focus_border_insets.left(),
+                         -focus_border_insets.top());
+      label->SetBoundsRect(gfx::Rect(view_origin, view_size));
+      x += view_size.width() - focus_border_insets.width();
+      used_width = std::max(used_width, x);
+      total_height =
+          std::max(total_height, label->bounds().bottom() + insets.bottom() -
+                                     focus_border_insets.bottom());
+    } else {
+      label->SetBoundsRect(gfx::Rect(view_origin, view_size));
+      x += view_size.width();
+      total_height =
+          std::max(total_height, label->bounds().bottom() + insets.bottom());
+    }
     used_width = std::max(used_width, x);
-    total_height =
-        std::max(total_height, label->bounds().bottom() + insets.bottom() -
-                                   focus_border_insets.bottom());
+
     if (!dry_run)
       AddChildView(label.release());
 
     // If |gfx::ElideRectangleText| returned more than one substring, that
     // means the whole text did not fit into remaining line width, with text
     // after |susbtring[0]| spilling into next line. If whole |substring[0]|
     // was added to the current line (this may not be the case if part of the
     // substring has different style), proceed to the next line.
     if (substrings.size() > 1 && chunk.size() == substrings[0].size()) {
       x = 0;
       ++line;
     }
 
     remaining_string = remaining_string.substr(chunk.size());
   }
 
   DCHECK_LE(used_width, width);
   calculated_size_ = gfx::Size(used_width + GetInsets().width(), total_height);
   return calculated_size_;
 }
 
 }  // namespace views