Supports FontList::DeriveFontListWithSizeDeltaAndStyle, etc.

ui/gfx/font_list.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/gfx/font_list.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 52 matching lines @@
                                  int font_size) {
   std::string description = JoinString(font_names, ',');
   description += "," + FontStyleAndSizeToString(font_style, font_size);
   return description;
 }
 
 }  // namespace
 
 namespace gfx {
 
-FontList::FontList() : common_height_(-1), common_baseline_(-1) {
+FontList::FontList()
+    : common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
   fonts_.push_back(Font());
 }
 
 FontList::FontList(const std::string& font_description_string)
     : font_description_string_(font_description_string),
       common_height_(-1),
-      common_baseline_(-1) {
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
   DCHECK(!font_description_string.empty());
   // DCHECK description string ends with "px" for size in pixel.
   DCHECK(EndsWith(font_description_string, "px", true));
 }
 
+FontList::FontList(const std::vector<std::string>& font_names,
+                   int font_style,
+                   int font_size)
+    : font_description_string_(BuildFontDescription(font_names, font_style,
+                                                    font_size)),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(font_style),
+      font_size_(font_size) {
+  DCHECK(!font_names.empty());
+  DCHECK(!font_names[0].empty());
+}
+
 FontList::FontList(const std::vector<Font>& fonts)
     : fonts_(fonts),
       common_height_(-1),
-      common_baseline_(-1) {
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
   DCHECK(!fonts.empty());
+  font_style_ = fonts[0].GetStyle();
+  font_size_ = fonts[0].GetFontSize();
   if (DCHECK_IS_ON()) {
-    int style = fonts[0].GetStyle();
-    int size = fonts[0].GetFontSize();
     for (size_t i = 1; i < fonts.size(); ++i) {
-      DCHECK_EQ(fonts[i].GetStyle(), style);
-      DCHECK_EQ(fonts[i].GetFontSize(), size);
+      DCHECK_EQ(fonts[i].GetStyle(), font_style_);
+      DCHECK_EQ(fonts[i].GetFontSize(), font_size_);
     }
   }
 }
 
 FontList::FontList(const Font& font)
     : common_height_(-1),
-      common_baseline_(-1) {
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
   fonts_.push_back(font);
 }
 
 FontList::~FontList() {
 }
 
 FontList FontList::DeriveFontList(int font_style) const {
+  return DeriveFontListWithSizeDeltaAndStyle(0, font_style);
+}
+
+FontList FontList::DeriveFontListWithSize(int size) const {
+  DCHECK_GT(size, 0);
+  return DeriveFontListWithSizeDeltaAndStyle(size - GetFontSize(),
+                                             GetFontStyle());
+}
+
+FontList FontList::DeriveFontListWithSizeDelta(int size_delta) const {
+  return DeriveFontListWithSizeDeltaAndStyle(size_delta, GetFontStyle());
+}
+
+FontList FontList::DeriveFontListWithSizeDeltaAndStyle(int size_delta,
+                                                       int style) const {
   // If there is a font vector, derive from that.
   if (!fonts_.empty()) {
     std::vector<Font> fonts = fonts_;
     for (size_t i = 0; i < fonts.size(); ++i)
-      fonts[i] = fonts[i].DeriveFont(0, font_style);
+      fonts[i] = fonts[i].DeriveFont(size_delta, style);
     return FontList(fonts);
   }
 
   // Otherwise, parse the font description string to derive from it.
   std::vector<std::string> font_names;
+  int old_size;
   int old_style;
-  int font_size;
   ParseFontDescriptionString(font_description_string_, &font_names,
-                             &old_style, &font_size);
-  return FontList(BuildFontDescription(font_names, font_style, font_size));
-}
-
-FontList FontList::DeriveFontListWithSize(int size) const {
+                             &old_style, &old_size);
+  int size = old_size + size_delta;
   DCHECK_GT(size, 0);
-
-  // If there is a font vector, derive from that.
-  int old_size = 0;
-  if (!fonts_.empty()) {
-    old_size = fonts_[0].GetFontSize();
-    if (old_size == size)
-      return FontList(fonts_);
-
-    std::vector<Font> fonts = fonts_;
-    for (size_t i = 0; i < fonts.size(); ++i)
-      fonts[i] = fonts[i].DeriveFont(size - old_size);
-    return FontList(fonts);
-  }
-
-  // Otherwise, parse the font description string to derive from it.
-  std::vector<std::string> font_names;
-  int font_style = 0;
-  ParseFontDescriptionString(font_description_string_, &font_names,
-                             &font_style, &old_size);
-
-  if (old_size == size)
-    return FontList(font_description_string_);
-
-  return FontList(BuildFontDescription(font_names, font_style, size));
+  return FontList(font_names, style, size);
 }
 
 int FontList::GetHeight() const {
-  if (common_height_ < 0) {
-    int ascent = 0;
-    int descent = 0;
-    const std::vector<Font>& fonts = GetFonts();
-    for (std::vector<Font>::const_iterator i = fonts.begin();
-         i != fonts.end(); ++i) {
-      ascent = std::max(ascent, i->GetBaseline());
-      descent = std::max(descent, i->GetHeight() - i->GetBaseline());
-    }
-    common_height_ = ascent + descent;
-  }
+  if (common_height_ == -1)
+    CacheCommonFontHeightAndBaseline();
   return common_height_;
 }
 
 int FontList::GetBaseline() const {
-  if (common_baseline_ < 0) {
-    int baseline = 0;
-    const std::vector<Font>& fonts = GetFonts();
-    for (std::vector<Font>::const_iterator i = fonts.begin();
-         i != fonts.end(); ++i) {
-      baseline = std::max(baseline, i->GetBaseline());
-    }
-    common_baseline_ = baseline;
-  }
+  if (common_baseline_ == -1)
+    CacheCommonFontHeightAndBaseline();
   return common_baseline_;
 }
 
+int FontList::GetStringWidth(const base::string16& text) const {
+  // Rely on the primary font metrics for the time being.
+  return GetPrimaryFont().GetStringWidth(text);

[Alexei Svitkine (slow), 2013/08/07 19:30:44]

This function is pretty bad, since GetStringWidth() ends up using
CanvasSkia::GetStringWidth() which ends up constructing a RenderText instance to
layout the text and get its width.

The problem is that this implementation now loses the FontList info, since it
only ends up passing the first font to RenderText.

Ideally, callers should stop using this API entirely and go through CanvasSkia
directly (to remove the circular dependency), to get this info, or as a stop-gap
to add a CanvasSkia::GetStringWidth() API that takes a FontList and passes it to
RenderText and then call that version of the API from here.

Please do that either in this CL or in a follow-up CL with a TODO here for now.

[Yuki, 2013/08/08 06:37:36]

Let me work on it in a separate CL.
Added a TODO comment.

+}
+
+int FontList::GetExpectedTextWidth(int length) const {
+  // Rely on the primary font metrics for the time being.
+  return GetPrimaryFont().GetExpectedTextWidth(length);
+}
+
 int FontList::GetFontStyle() const {
-  if (!fonts_.empty())
-    return fonts_[0].GetStyle();
-
-  std::vector<std::string> font_names;
-  int font_style;
-  int font_size;
-  ParseFontDescriptionString(font_description_string_, &font_names,
-                             &font_style, &font_size);
-  return font_style;
+  if (font_style_ == -1)
+    CacheFontStyleAndSize();
+  return font_style_;
 }
 
 const std::string& FontList::GetFontDescriptionString() const {
   if (font_description_string_.empty()) {
     DCHECK(!fonts_.empty());
     for (size_t i = 0; i < fonts_.size(); ++i) {
       std::string name = fonts_[i].GetFontName();
       font_description_string_ += name;
       font_description_string_ += ',';
     }
     // All fonts have the same style and size.
     font_description_string_ +=
         FontStyleAndSizeToString(fonts_[0].GetStyle(), fonts_[0].GetFontSize());
   }
   return font_description_string_;
 }
 
 int FontList::GetFontSize() const {
-  if (!fonts_.empty())
-    return fonts_[0].GetFontSize();
-
-  std::vector<std::string> font_names;
-  int font_style;
-  int font_size;
-  ParseFontDescriptionString(font_description_string_, &font_names,
-                             &font_style, &font_size);
-  return font_size;
+  if (font_size_ == -1)
+    CacheFontStyleAndSize();
+  return font_size_;
 }
 
 const std::vector<Font>& FontList::GetFonts() const {
   if (fonts_.empty()) {
     DCHECK(!font_description_string_.empty());
 
     std::vector<std::string> font_names;
-    int font_style;
-    int font_size;
     ParseFontDescriptionString(font_description_string_, &font_names,
-                               &font_style, &font_size);
+                               &font_style_, &font_size_);
     for (size_t i = 0; i < font_names.size(); ++i) {
       DCHECK(!font_names[i].empty());
 
-      Font font(font_names[i], font_size);
-      if (font_style == Font::NORMAL)
+      Font font(font_names[i], font_size_);
+      if (font_style_ == Font::NORMAL)
         fonts_.push_back(font);
       else
-        fonts_.push_back(font.DeriveFont(0, font_style));
+        fonts_.push_back(font.DeriveFont(0, font_style_));
     }
   }
   return fonts_;
 }
 
 const Font& FontList::GetPrimaryFont() const {
   return GetFonts()[0];
 }
 
+void FontList::CacheCommonFontHeightAndBaseline() const {
+  int ascent = 0;
+  int descent = 0;
+  const std::vector<Font>& fonts = GetFonts();
+  for (std::vector<Font>::const_iterator i = fonts.begin();
+       i != fonts.end(); ++i) {
+    ascent = std::max(ascent, i->GetBaseline());
+    descent = std::max(descent, i->GetHeight() - i->GetBaseline());
+  }
+  common_height_ = ascent + descent;
+  common_baseline_ = ascent;
+}
+
+void FontList::CacheFontStyleAndSize() const {
+  if (!fonts_.empty()) {
+    font_style_ = fonts_[0].GetStyle();
+    font_size_ = fonts_[0].GetFontSize();
+  } else {
+    std::vector<std::string> font_names;
+    ParseFontDescriptionString(font_description_string_, &font_names,
+                               &font_style_, &font_size_);
+  }
+}
+
 }  // namespace gfx