Make FontList description-parsing public.

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 "base/lazy_instance.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "ui/gfx/font_list_impl.h"
 
 namespace {
 
 // Font description of the default font set.
 base::LazyInstance<std::string>::Leaky g_default_font_description =
     LAZY_INSTANCE_INITIALIZER;
 
 // The default instance of gfx::FontListImpl.
 base::LazyInstance<scoped_refptr<gfx::FontListImpl> >::Leaky g_default_impl =
     LAZY_INSTANCE_INITIALIZER;
 bool g_default_impl_initialized = false;
 
 }  // namespace
 
 namespace gfx {
 
+// static
+bool FontList::ParseDescription(const std::string& description,
+                                std::vector<std::string>* families_out,
+                                int* style_out,
+                                int* size_pixels_out) {
+  DCHECK(families_out);
+  DCHECK(style_out);
+  DCHECK(size_pixels_out);
+
+  base::SplitString(description, ',', families_out);
+  if (families_out->empty())
+    return false;
+  for (auto it = families_out->begin(); it != families_out->end(); ++it)

[Yuki, 2015/02/09 04:41:29]

Could you use the following form?

  for (auto& family : *families_out)
    base::TrimWhitespaceASCII(family, base::TRIM_ALL, &family);

[Daniel Erat, 2015/02/09 16:23:47]

sure, done. thanks for the quick review!

+    base::TrimWhitespaceASCII(*it, base::TRIM_ALL, &(*it));
+
+  // The last item is "[STYLE1] [STYLE2] [...] SIZE".
+  std::vector<std::string> styles;
+  base::SplitStringAlongWhitespace(families_out->back(), &styles);
+  families_out->pop_back();
+  if (styles.empty())
+    return false;
+
+  // The size takes the form "<INT>px".
+  std::string size_string = styles.back();
+  styles.pop_back();
+  if (!EndsWith(size_string, "px", true /* case_sensitive */))
+    return false;
+  size_string.resize(size_string.size() - 2);
+  if (!base::StringToInt(size_string, size_pixels_out) ||
+      *size_pixels_out <= 0)
+    return false;
+
+  // Font supports BOLD and ITALIC; underline is supported via RenderText.
+  *style_out = gfx::Font::NORMAL;
+  for (const auto& style_string : styles) {
+    if (style_string == "Bold")
+      *style_out |= gfx::Font::BOLD;
+    else if (style_string == "Italic")
+      *style_out |= gfx::Font::ITALIC;
+    else
+      return false;
+  }
+
+  return true;
+}
+
 FontList::FontList() : impl_(GetDefaultImpl()) {}
 
 FontList::FontList(const FontList& other) : impl_(other.impl_) {}
 
 FontList::FontList(const std::string& font_description_string)
     : impl_(new FontListImpl(font_description_string)) {}
 
 FontList::FontList(const std::vector<std::string>& font_names,
                    int font_style,
                    int font_size)
@@ skipping 68 matching lines @@
 }
 
 int FontList::GetExpectedTextWidth(int length) const {
   return impl_->GetExpectedTextWidth(length);
 }
 
 int FontList::GetFontStyle() const {
   return impl_->GetFontStyle();
 }
 
-const std::string& FontList::GetFontDescriptionString() const {
-  return impl_->GetFontDescriptionString();
-}
-
 int FontList::GetFontSize() const {
   return impl_->GetFontSize();
 }
 
 const std::vector<Font>& FontList::GetFonts() const {
   return impl_->GetFonts();
 }
 
 const Font& FontList::GetPrimaryFont() const {
   return impl_->GetPrimaryFont();
@@ skipping 13 matching lines @@
         g_default_font_description.Get().empty() ?
             new FontListImpl(Font()) :
             new FontListImpl(g_default_font_description.Get());
     g_default_impl_initialized = true;
   }
 
   return g_default_impl.Get();
 }
 
 }  // namespace gfx