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

ui/views/controls/label.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 "ui/views/controls/label.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/default_style.h"
-#include "ui/base/material_design/material_design_controller.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/native_cursor.h"
 #include "ui/views/selection_controller.h"
 
 namespace views {
-// static
+namespace {
+// Returns additional Insets applied to |label->GetContentsBounds()| to obtain
+// the text bounds. GetContentsBounds() includes the Border, but not any
+// additional insets used by the Label (e.g. for a focus ring).
+gfx::Insets NonBorderInsets(const Label& label) {
+  return label.GetInsets() - label.View::GetInsets();
+}
+}  // namespace
+
 const char Label::kViewClassName[] = "Label";
-const int Label::kFocusBorderPadding = 1;
 
 Label::Label() : Label(base::string16()) {
 }
 
 Label::Label(const base::string16& text)
     : Label(text, style::CONTEXT_LABEL, style::STYLE_PRIMARY) {}
 
 Label::Label(const base::string16& text, int text_context, int text_style)
     : context_menu_contents_(this) {
   Init(text, style::GetFont(text_context, text_style));
@@ skipping 243 matching lines @@
   render_text->ClearSelection();
   SchedulePaint();
 }
 
 void Label::SelectRange(const gfx::Range& range) {
   gfx::RenderText* render_text = GetRenderTextForSelectionController();
   if (render_text && render_text->SelectRange(range))
     SchedulePaint();
 }
 
-gfx::Insets Label::GetInsets() const {
-  gfx::Insets insets = View::GetInsets();
-  if (focus_behavior() != FocusBehavior::NEVER) {
-    insets += gfx::Insets(kFocusBorderPadding, kFocusBorderPadding,
-                          kFocusBorderPadding, kFocusBorderPadding);
-  }
-  return insets;
-}
-
 int Label::GetBaseline() const {
   return GetInsets().top() + font_list().GetBaseline();
 }
 
 gfx::Size Label::GetPreferredSize() const {
   // Return a size of (0, 0) if the label is not visible and if the
   // |collapse_when_hidden_| flag is set.
   // TODO(munjal): This logic probably belongs to the View class. But for now,
   // put it here since putting it in View class means all inheriting classes
   // need to respect the |collapse_when_hidden_| flag.
@@ skipping 122 matching lines @@
   render_text->SetElideBehavior(elide_behavior);
   render_text->SetObscured(obscured());
   render_text->SetMinLineHeight(line_height());
   render_text->SetFontList(font_list());
   render_text->set_shadows(shadows());
   render_text->SetCursorEnabled(false);
   render_text->SetText(text);
   return render_text;
 }
 
+void Label::PaintFocusRing(gfx::Canvas* canvas) const {
+  // No focus ring by default.
+}
+
+gfx::Rect Label::GetFocusRingBounds() const {
+  MaybeBuildRenderTextLines();
+
+  gfx::Rect focus_bounds;
+  if (lines_.empty()) {
+    focus_bounds = gfx::Rect(GetTextSize());
+  } else {
+    for (size_t i = 0; i < lines_.size(); ++i) {
+      gfx::Point origin;
+      origin += lines_[i]->GetLineOffset(0);
+      focus_bounds.Union(gfx::Rect(origin, lines_[i]->GetStringSize()));
+    }
+  }
+
+  focus_bounds.Inset(-NonBorderInsets(*this));
+  focus_bounds.Intersect(GetLocalBounds());
+  return focus_bounds;
+}
+
 void Label::PaintText(gfx::Canvas* canvas) {
   MaybeBuildRenderTextLines();
 
   for (size_t i = 0; i < lines_.size(); ++i)
     lines_[i]->Draw(canvas);
 
 #if DCHECK_IS_ON()
   // Attempt to ensure that if we're using subpixel rendering, we're painting
   // to an opaque background. What we don't want to find is an ancestor in the
   // hierarchy that paints to a non-opaque layer.
@@ skipping 26 matching lines @@
     // fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("441028 First PaintText()"));
 
     is_first_paint_text_ = false;
     PaintText(canvas);
   } else {
     PaintText(canvas);
   }
 
-  // Check for IsAccessibilityFocusable() to prevent drawing a focus rect for
-  // non-focusable labels with selection, which are given focus explicitly in
-  // OnMousePressed.
-  if (HasFocus() && !ui::MaterialDesignController::IsSecondaryUiMaterial() &&
-      IsAccessibilityFocusable()) {
-    canvas->DrawFocusRect(GetFocusBounds());
-  }
+  if (HasFocus())
+    PaintFocusRing(canvas);
 }
 
 void Label::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   UpdateColorsFromTheme(theme);
 }
 
 gfx::NativeCursor Label::GetCursor(const ui::MouseEvent& event) {
   return GetRenderTextForSelectionController() ? GetNativeIBeamCursor()
                                                : gfx::kNullCursor;
 }
@@ skipping 317 matching lines @@
   PreferredSizeChanged();
   SchedulePaint();
   ClearRenderTextLines();
 }
 
 void Label::MaybeBuildRenderTextLines() const {
   if (!lines_.empty())
     return;
 
   gfx::Rect rect = GetContentsBounds();
-  if (focus_behavior() != FocusBehavior::NEVER)
-    rect.Inset(kFocusBorderPadding, kFocusBorderPadding);
+  rect.Inset(NonBorderInsets(*this));
   if (rect.IsEmpty())
     return;
+
   rect.Inset(-gfx::ShadowValue::GetMargin(shadows()));
 
   gfx::HorizontalAlignment alignment = horizontal_alignment();
   gfx::DirectionalityMode directionality = render_text_->directionality_mode();
   if (multi_line()) {
     // Force the directionality and alignment of the first line on other lines.
     bool rtl =
         render_text_->GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT;
     if (alignment == gfx::ALIGN_TO_HEAD)
       alignment = rtl ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
@@ skipping 35 matching lines @@
     }
     // Append the remaining text to the last visible line.
     for (size_t i = lines_.size(); i < lines.size(); ++i)
       lines_.back()->SetText(lines_.back()->text() + lines[i]);
   }
 
   stored_selection_range_ = gfx::Range::InvalidRange();
   ApplyTextColors();
 }
 
-gfx::Rect Label::GetFocusBounds() const {
-  MaybeBuildRenderTextLines();
-
-  gfx::Rect focus_bounds;
-  if (lines_.empty()) {
-    focus_bounds = gfx::Rect(GetTextSize());
-  } else {
-    for (size_t i = 0; i < lines_.size(); ++i) {
-      gfx::Point origin;
-      origin += lines_[i]->GetLineOffset(0);
-      focus_bounds.Union(gfx::Rect(origin, lines_[i]->GetStringSize()));
-    }
-  }
-
-  focus_bounds.Inset(-kFocusBorderPadding, -kFocusBorderPadding);
-  focus_bounds.Intersect(GetLocalBounds());
-  return focus_bounds;
-}
-
 std::vector<base::string16> Label::GetLinesForWidth(int width) const {
   std::vector<base::string16> lines;
   // |width| can be 0 when getting the default text size, in that case
   // the ideal lines (i.e. broken at newline characters) are wanted.
   if (width <= 0) {
     lines = base::SplitString(
         render_text_->GetDisplayText(), base::string16(1, '\n'),
         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   } else {
     gfx::ElideRectangleText(render_text_->GetDisplayText(), font_list(), width,
@@ skipping 125 matching lines @@
       .WriteText(GetSelectedText());
 }
 
 void Label::BuildContextMenuContents() {
   context_menu_contents_.AddItemWithStringId(IDS_APP_COPY, IDS_APP_COPY);
   context_menu_contents_.AddItemWithStringId(IDS_APP_SELECT_ALL,
                                              IDS_APP_SELECT_ALL);
 }
 
 }  // namespace views