Use views::style for buttons, bootstrap ash_typography to do so.

ui/views/controls/button/label_button.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/button/label_button.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/layout/layout_provider.h"
 #include "ui/views/painter.h"
 #include "ui/views/style/platform_style.h"
 #include "ui/views/window/dialog_delegate.h"
 
-namespace {
-
-gfx::Font::Weight GetValueBolderThan(gfx::Font::Weight weight) {
-  if (weight < gfx::Font::Weight::BOLD)
-    return gfx::Font::Weight::BOLD;
-  switch (weight) {
-    case gfx::Font::Weight::BOLD:
-      return gfx::Font::Weight::EXTRA_BOLD;
-    case gfx::Font::Weight::EXTRA_BOLD:
-    case gfx::Font::Weight::BLACK:
-      return gfx::Font::Weight::BLACK;
-    default:
-      NOTREACHED();
-  }
-  return gfx::Font::Weight::INVALID;
-}
-
-const gfx::FontList& GetDefaultNormalFontList() {
-  static base::LazyInstance<gfx::FontList>::Leaky font_list =
-      LAZY_INSTANCE_INITIALIZER;
-  return font_list.Get();
-}
-
-const gfx::FontList& GetDefaultBoldFontList() {
-  if (!views::PlatformStyle::kDefaultLabelButtonHasBoldFont)
-    return GetDefaultNormalFontList();
-
-  static base::LazyInstance<gfx::FontList>::Leaky font_list =
-      LAZY_INSTANCE_INITIALIZER;
-
-  static const gfx::Font::Weight default_bold_weight =
-      font_list.Get().GetFontWeight();
-
-  font_list.Get() = font_list.Get().DeriveWithWeight(
-      GetValueBolderThan(default_bold_weight));
-  DCHECK_GE(font_list.Get().GetFontWeight(), gfx::Font::Weight::BOLD);
-
-  return font_list.Get();
-}
-
-}  // namespace
-
 namespace views {
 
 // static
 const int LabelButton::kHoverAnimationDurationMs = 170;
 const char LabelButton::kViewClassName[] = "LabelButton";
 
-LabelButton::LabelButton(ButtonListener* listener, const base::string16& text)
+LabelButton::LabelButton(ButtonListener* listener,
+                         const base::string16& text,
+                         int button_context)
     : CustomButton(listener),
       image_(new ImageView()),
-      label_(new Label()),
+      label_(new Label(text, button_context, style::STYLE_PRIMARY)),
       ink_drop_container_(new InkDropContainerView()),
-      cached_normal_font_list_(GetDefaultNormalFontList()),
-      cached_bold_font_list_(GetDefaultBoldFontList()),
+      cached_normal_font_list_(
+          style::GetFont(button_context, style::STYLE_PRIMARY)),
+      cached_default_button_font_list_(
+          style::GetFont(button_context, style::STYLE_DIALOG_BUTTON_DEFAULT)),
       button_state_images_(),
       button_state_colors_(),
       explicitly_set_colors_(),
       is_default_(false),
       style_(STYLE_TEXTBUTTON),
       border_is_themed_border_(true),
       image_label_spacing_(LayoutProvider::Get()->GetDistanceMetric(
           DISTANCE_RELATED_CONTROL_HORIZONTAL)),
       horizontal_alignment_(gfx::ALIGN_LEFT) {
   SetAnimationDuration(kHoverAnimationDurationMs);
-  SetTextInternal(text);
+  SetAccessibleName(text);

[sky, 2017/05/12 17:00:11]

It seems less error prone to call SetTextInternal here. Is there a compelling
reason not to?

[tapted, 2017/05/15 23:02:32]

Went back to SetTextInternal.

This means the text is set twice - once in the initializer and once in
SetTextInternal. Performance isn't a huge deal since Label::SetText doesn't do
too much and RenderText::SetText has an early exit.  My thinking was just that
SetTextInternal could suggest the SetText call was still necessary, where it is
now not.

 
   AddChildView(ink_drop_container_);
   ink_drop_container_->SetPaintToLayer();
   ink_drop_container_->layer()->SetFillsBoundsOpaquely(false);
   ink_drop_container_->SetVisible(false);
 
   AddChildView(image_);
   image_->set_can_process_events_within_subtree(false);
 
   AddChildView(label_);
-  label_->SetFontList(cached_normal_font_list_);
   label_->SetAutoColorReadabilityEnabled(false);
   label_->SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
 
   // Inset the button focus rect from the actual border; roughly match Windows.
   SetFocusPainter(Painter::CreateDashedFocusPainterWithInsets(gfx::Insets(3)));
 }
 
 LabelButton::~LabelButton() {}
 
 gfx::ImageSkia LabelButton::GetImage(ButtonState for_state) const {
@@ skipping 31 matching lines @@
 }
 
 void LabelButton::SetTextShadows(const gfx::ShadowValues& shadows) {
   label_->SetShadows(shadows);
 }
 
 void LabelButton::SetTextSubpixelRenderingEnabled(bool enabled) {
   label_->SetSubpixelRenderingEnabled(enabled);
 }
 
-void LabelButton::AdjustFontSize(int font_size_delta) {
-  LabelButton::SetFontList(
-      label()->font_list().DeriveWithSizeDelta(font_size_delta));
-}
-
 void LabelButton::SetElideBehavior(gfx::ElideBehavior elide_behavior) {
   label_->SetElideBehavior(elide_behavior);
 }
 
 void LabelButton::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
   DCHECK_NE(gfx::ALIGN_TO_HEAD, alignment);
   horizontal_alignment_ = alignment;
   InvalidateLayout();
 }
 
@@ skipping 57 matching lines @@
 
   // Use a temporary label copy for sizing to avoid calculation side-effects.
   Label label(GetText(), {label_->font_list()});
   label.SetLineHeight(label_->line_height());
   label.SetShadows(label_->shadows());
 
   if (style_ == STYLE_BUTTON && PlatformStyle::kDefaultLabelButtonHasBoldFont) {
     // Some text appears wider when rendered normally than when rendered bold.
     // Accommodate the widest, as buttons may show bold and shouldn't resize.
     const int current_width = label.GetPreferredSize().width();
-    label.SetFontList(cached_bold_font_list_);
+    label.SetFontList(cached_default_button_font_list_);
     if (label.GetPreferredSize().width() < current_width)
       label.SetFontList(label_->font_list());
   }
 
   // Calculate the required size.
   const gfx::Size image_size(image_->GetPreferredSize());
   gfx::Size size(label.GetPreferredSize());
   if (image_size.width() > 0 && size.width() > 0)
     size.Enlarge(image_label_spacing_, 0);
   size.SetToMax(gfx::Size(0, image_size.height()));
@@ skipping 116 matching lines @@
 void LabelButton::SetBorder(std::unique_ptr<Border> border) {
   border_is_themed_border_ = false;
   View::SetBorder(std::move(border));
   ResetCachedPreferredSize();
 }
 
 gfx::Rect LabelButton::GetChildAreaBounds() {
   return GetLocalBounds();
 }
 
-void LabelButton::SetFontList(const gfx::FontList& font_list) {
-  cached_normal_font_list_ = font_list;
-  if (PlatformStyle::kDefaultLabelButtonHasBoldFont) {
-    cached_bold_font_list_ = font_list.DeriveWithWeight(
-        GetValueBolderThan(font_list.GetFontWeight()));
-    if (is_default_) {
-      label_->SetFontList(cached_bold_font_list_);
-      return;
-    }
-  }
-  label_->SetFontList(cached_normal_font_list_);
-}
-
 void LabelButton::OnPaint(gfx::Canvas* canvas) {
   View::OnPaint(canvas);
   Painter::PaintFocusPainter(this, canvas, focus_painter_.get());
 }
 
 void LabelButton::OnFocus() {
   CustomButton::OnFocus();
   // Typically the border renders differently when focused.
   SchedulePaint();
 }
@@ skipping 111 matching lines @@
 
   for (size_t state = STATE_NORMAL; state < STATE_COUNT; ++state) {
     if (!explicitly_set_colors_[state]) {
       SetTextColor(static_cast<ButtonState>(state), colors[state]);
       explicitly_set_colors_[state] = false;
     }
   }
 }
 
 void LabelButton::UpdateStyleToIndicateDefaultStatus() {
+  // Check that a subclass hasn't replaced the Label font. These buttons may
+  // never be given default status.
+  DCHECK_EQ(cached_normal_font_list_.GetFontSize(),
+            label()->font_list().GetFontSize());
   const bool bold =
       PlatformStyle::kDefaultLabelButtonHasBoldFont && is_default_;
-  label_->SetFontList(bold ? cached_bold_font_list_ : cached_normal_font_list_);
+  // TODO(tapted): This should use style::GetFont(), but this part can just be
+  // deleted when default buttons no longer go bold. Colors will need updating
+  // still.
+  label_->SetFontList(bold ? cached_default_button_font_list_
+                           : cached_normal_font_list_);
   InvalidateLayout();
   ResetLabelEnabledColor();
 }
 
 void LabelButton::UpdateImage() {
   image_->SetImage(GetImage(state()));
   ResetCachedPreferredSize();
 }
 
 void LabelButton::UpdateThemedBorder() {
@@ skipping 65 matching lines @@
           : PlatformStyle::TextColorForButton(button_state_colors_, *this);
   if (state() != STATE_DISABLED && label_->enabled_color() != color)
     label_->SetEnabledColor(color);
 }
 
 bool LabelButton::UseFloodFillInkDrop() const {
   return !GetText().empty();
 }
 
 }  // namespace views