Make FontList description-parsing public.

ui/gfx/font_list_unittest.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 <string>
 #include <vector>
 
@@ skipping 15 matching lines @@
     font_string += "|italic";
   if (style & gfx::Font::UNDERLINE)
     font_string += "|underline";
   return font_string;
 }
 
 }  // namespace
 
 namespace gfx {
 
-TEST(FontListTest, FontDescString_FromDescString) {
-  // Test init from font name style size string.
-  FontList font_list = FontList("Droid Sans serif, Sans serif, 10px");
-  EXPECT_EQ("Droid Sans serif, Sans serif, 10px",
-            font_list.GetFontDescriptionString());
-}
+TEST(FontListTest, ParseDescription) {
+  std::vector<std::string> families;
+  int style = gfx::Font::NORMAL;
+  int size_pixels = 0;
 
-TEST(FontListTest, FontDescString_FromFontNamesStyleAndSize) {
-  // Test init from font names, style and size.
-  std::vector<std::string> font_names;
-  font_names.push_back("Arial");
-  font_names.push_back("Droid Sans serif");
-  int font_style = Font::BOLD | Font::ITALIC | Font::UNDERLINE;
-  int font_size = 11;
-  FontList font_list = FontList(font_names, font_style, font_size);
-  // "Underline" doesn't appear in the font description string.
-  EXPECT_EQ("Arial,Droid Sans serif,Bold Italic 11px",
-            font_list.GetFontDescriptionString());
-}
+  // Parse a well-formed description containing styles and a size.
+  EXPECT_TRUE(FontList::ParseDescription("Arial,Helvetica,Bold Italic 12px",
+                                         &families, &style, &size_pixels));
+  ASSERT_EQ(2U, families.size());
+  EXPECT_EQ("Arial", families[0]);
+  EXPECT_EQ("Helvetica", families[1]);
+  EXPECT_EQ(gfx::Font::BOLD | gfx::Font::ITALIC, style);
+  EXPECT_EQ(12, size_pixels);
 
-TEST(FontListTest, FontDescString_FromFont) {
-  // Test init from Font.
-  Font font("Arial", 8);
-  FontList font_list = FontList(font);
-  EXPECT_EQ("Arial,8px", font_list.GetFontDescriptionString());
-}
+  // Whitespace should be removed.
+  EXPECT_TRUE(FontList::ParseDescription("  Verdana , Italic  Bold   10px ",
+                                         &families, &style, &size_pixels));
+  ASSERT_EQ(1U, families.size());
+  EXPECT_EQ("Verdana", families[0]);
+  EXPECT_EQ(gfx::Font::BOLD | gfx::Font::ITALIC, style);
+  EXPECT_EQ(10, size_pixels);
 
-TEST(FontListTest, FontDescString_FromFontWithNonNormalStyle) {
-  // Test init from Font with non-normal style.
-  Font font("Arial", 8);
-  FontList font_list = FontList(font.Derive(2, Font::BOLD));
-  EXPECT_EQ("Arial,Bold 10px", font_list.GetFontDescriptionString());
-
-  font_list = FontList(font.Derive(-2, Font::ITALIC));
-  EXPECT_EQ("Arial,Italic 6px", font_list.GetFontDescriptionString());
-
-  // "Underline" doesn't appear in the font description string.
-  font_list = FontList(font.Derive(-4, Font::UNDERLINE));
-  EXPECT_EQ("Arial,4px", font_list.GetFontDescriptionString());
-}
-
-TEST(FontListTest, FontDescString_FromFontVector) {
-  // Test init from Font vector.
-  Font font("Arial", 8);
-  Font font_1("Sans serif", 10);
-  std::vector<Font> fonts;
-  fonts.push_back(font.Derive(0, Font::BOLD));
-  fonts.push_back(font_1.Derive(-2, Font::BOLD));
-  FontList font_list = FontList(fonts);
-  EXPECT_EQ("Arial,Sans serif,Bold 8px", font_list.GetFontDescriptionString());
+  // Invalid descriptions should be rejected.
+  EXPECT_FALSE(FontList::ParseDescription("", &families, &style, &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial", &families, &style,
+                                          &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,12", &families, &style,
+                                          &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial 12px", &families, &style,
+                                          &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,12px,", &families, &style,
+                                          &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,0px", &families, &style,
+                                          &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,-1px", &families, &style,
+                                          &size_pixels));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,foo 12px", &families, &style,
+                                          &size_pixels));
 }
 
 TEST(FontListTest, Fonts_FromDescString) {
   // Test init from font name size string.
   FontList font_list = FontList("serif,Sans serif, 13px");
   const std::vector<Font>& fonts = font_list.GetFonts();
-  EXPECT_EQ(2U, fonts.size());
+  ASSERT_EQ(2U, fonts.size());
   EXPECT_EQ("serif|13", FontToString(fonts[0]));
   EXPECT_EQ("Sans serif|13", FontToString(fonts[1]));
 }
 
 TEST(FontListTest, Fonts_FromDescStringInFlexibleFormat) {
   // Test init from font name size string with flexible format.
   FontList font_list = FontList("  serif   ,   Sans serif ,   13px");
   const std::vector<Font>& fonts = font_list.GetFonts();
-  EXPECT_EQ(2U, fonts.size());
+  ASSERT_EQ(2U, fonts.size());
   EXPECT_EQ("serif|13", FontToString(fonts[0]));
   EXPECT_EQ("Sans serif|13", FontToString(fonts[1]));
 }
 
 TEST(FontListTest, Fonts_FromDescStringWithStyleInFlexibleFormat) {
   // Test init from font name style size string with flexible format.
   FontList font_list = FontList("  serif  ,  Sans serif ,  Bold   "
                                 "  Italic   13px");
   const std::vector<Font>& fonts = font_list.GetFonts();
-  EXPECT_EQ(2U, fonts.size());
+  ASSERT_EQ(2U, fonts.size());
   EXPECT_EQ("serif|13|bold|italic", FontToString(fonts[0]));
   EXPECT_EQ("Sans serif|13|bold|italic", FontToString(fonts[1]));
 }
 
 TEST(FontListTest, Fonts_FromFont) {
   // Test init from Font.
   Font font("Arial", 8);
   FontList font_list = FontList(font);
   const std::vector<Font>& fonts = font_list.GetFonts();
-  EXPECT_EQ(1U, fonts.size());
+  ASSERT_EQ(1U, fonts.size());
   EXPECT_EQ("Arial|8", FontToString(fonts[0]));
 }
 
 TEST(FontListTest, Fonts_FromFontWithNonNormalStyle) {
   // Test init from Font with non-normal style.
   Font font("Arial", 8);
   FontList font_list = FontList(font.Derive(2, Font::BOLD));
   std::vector<Font> fonts = font_list.GetFonts();
-  EXPECT_EQ(1U, fonts.size());
+  ASSERT_EQ(1U, fonts.size());
   EXPECT_EQ("Arial|10|bold", FontToString(fonts[0]));
 
   font_list = FontList(font.Derive(-2, Font::ITALIC));
   fonts = font_list.GetFonts();
-  EXPECT_EQ(1U, fonts.size());
+  ASSERT_EQ(1U, fonts.size());
   EXPECT_EQ("Arial|6|italic", FontToString(fonts[0]));
 }
 
 TEST(FontListTest, Fonts_FromFontVector) {
   // Test init from Font vector.
   Font font("Arial", 8);
   Font font_1("Sans serif", 10);
   std::vector<Font> input_fonts;
   input_fonts.push_back(font.Derive(0, Font::BOLD));
   input_fonts.push_back(font_1.Derive(-2, Font::BOLD));
   FontList font_list = FontList(input_fonts);
   const std::vector<Font>& fonts = font_list.GetFonts();
-  EXPECT_EQ(2U, fonts.size());
+  ASSERT_EQ(2U, fonts.size());
   EXPECT_EQ("Arial|8|bold", FontToString(fonts[0]));
   EXPECT_EQ("Sans serif|8|bold", FontToString(fonts[1]));
 }
 
-TEST(FontListTest, Fonts_DescStringWithStyleInFlexibleFormat_RoundTrip) {
-  // Test round trip from font description string to font vector to
-  // font description string.
-  FontList font_list = FontList("  serif  ,  Sans serif ,  Bold   "
-                                "  Italic   13px");
-
-  const std::vector<Font>& fonts = font_list.GetFonts();
-  FontList font_list_1 = FontList(fonts);
-  const std::string& desc_str = font_list_1.GetFontDescriptionString();
-
-  EXPECT_EQ("serif,Sans serif,Bold Italic 13px", desc_str);
-}
-
-TEST(FontListTest, Fonts_FontVector_RoundTrip) {
-  // Test round trip from font vector to font description string to font vector.
-  Font font("Arial", 8);
-  Font font_1("Sans serif", 10);
-  std::vector<Font> input_fonts;
-  input_fonts.push_back(font.Derive(0, Font::BOLD));
-  input_fonts.push_back(font_1.Derive(-2, Font::BOLD));
-  FontList font_list = FontList(input_fonts);
-
-  const std::string& desc_string = font_list.GetFontDescriptionString();
-  FontList font_list_1 = FontList(desc_string);
-  const std::vector<Font>& round_trip_fonts = font_list_1.GetFonts();
-
-  EXPECT_EQ(2U, round_trip_fonts.size());
-  EXPECT_EQ("Arial|8|bold", FontToString(round_trip_fonts[0]));
-  EXPECT_EQ("Sans serif|8|bold", FontToString(round_trip_fonts[1]));
-}
-
 TEST(FontListTest, FontDescString_GetStyle) {
   FontList font_list = FontList("Arial,Sans serif, 8px");
   EXPECT_EQ(Font::NORMAL, font_list.GetFontStyle());
 
   font_list = FontList("Arial,Sans serif,Bold 8px");
   EXPECT_EQ(Font::BOLD, font_list.GetFontStyle());
 
   font_list = FontList("Arial,Sans serif,Italic 8px");
   EXPECT_EQ(Font::ITALIC, font_list.GetFontStyle());
 
   font_list = FontList("Arial,Italic Bold 8px");
   EXPECT_EQ(Font::BOLD | Font::ITALIC, font_list.GetFontStyle());
 }
 
 TEST(FontListTest, Fonts_GetStyle) {
   std::vector<Font> fonts;
   fonts.push_back(gfx::Font("Arial", 8));
   fonts.push_back(gfx::Font("Sans serif", 8));
   FontList font_list = FontList(fonts);
   EXPECT_EQ(Font::NORMAL, font_list.GetFontStyle());
   fonts[0] = fonts[0].Derive(0, Font::ITALIC | Font::BOLD);
   fonts[1] = fonts[1].Derive(0, Font::ITALIC | Font::BOLD);
   font_list = FontList(fonts);
   EXPECT_EQ(Font::ITALIC | Font::BOLD, font_list.GetFontStyle());
 }
 
-TEST(FontListTest, FontDescString_Derive) {
-  FontList font_list = FontList("Arial,Sans serif,Bold Italic 8px");
-
-  FontList derived = font_list.Derive(10, Font::ITALIC | Font::UNDERLINE);
-  EXPECT_EQ("Arial,Sans serif,Italic 18px", derived.GetFontDescriptionString());
-  EXPECT_EQ(Font::ITALIC | Font::UNDERLINE, derived.GetFontStyle());
-
-  // FontList has a special case for Font::UNDERLINE.  See if the handling of
-  // Font::UNDERLINE in GetFonts() is okay or not.
-  derived.GetFonts();
-  EXPECT_EQ(Font::ITALIC | Font::UNDERLINE, derived.GetFontStyle());
-}
-
 TEST(FontListTest, Fonts_Derive) {
   std::vector<Font> fonts;
   fonts.push_back(gfx::Font("Arial", 8));
   fonts.push_back(gfx::Font("Sans serif", 8));
   FontList font_list = FontList(fonts);
 
   FontList derived = font_list.Derive(5, Font::BOLD | Font::UNDERLINE);
   const std::vector<Font>& derived_fonts = derived.GetFonts();
 
   EXPECT_EQ(2U, derived_fonts.size());
   EXPECT_EQ("Arial|13|bold|underline", FontToString(derived_fonts[0]));
   EXPECT_EQ("Sans serif|13|bold|underline", FontToString(derived_fonts[1]));
 }
 
-TEST(FontListTest, FontDescString_DeriveWithSizeDelta) {
-  FontList font_list = FontList("Arial,Sans serif,Bold 18px");
-
-  FontList derived = font_list.DeriveWithSizeDelta(-8);
-  EXPECT_EQ("Arial,Sans serif,Bold 10px",
-            derived.GetFontDescriptionString());
-}
-
 TEST(FontListTest, Fonts_DeriveWithSizeDelta) {
   std::vector<Font> fonts;
   fonts.push_back(gfx::Font("Arial", 18).Derive(0, Font::ITALIC));
   fonts.push_back(gfx::Font("Sans serif", 18).Derive(0, Font::ITALIC));
   FontList font_list = FontList(fonts);
 
   FontList derived = font_list.DeriveWithSizeDelta(-5);
   const std::vector<Font>& derived_fonts = derived.GetFonts();
 
   EXPECT_EQ(2U, derived_fonts.size());
@@ skipping 48 matching lines @@
 
   // A larger upper bound should not change the height of the font list.
   const int height_2 = font_list.GetHeight() + 5;
   FontList derived_2 = font_list.DeriveWithHeightUpperBound(height_2);
   EXPECT_LE(derived_2.GetHeight(), height_2);
   EXPECT_EQ(font_list.GetHeight(), derived_2.GetHeight());
   EXPECT_EQ(font_list.GetFontSize(), derived_2.GetFontSize());
 }
 
 }  // namespace gfx