Revert 116945 - Enable bold and italic text styles in RenderText*.

To do this, the following changes were made:

Added functions GetStyle() and DeriveFontList(style) to FontList. Changed font list to use strings "Bold" and "Italic" instead of PANGO_STYLE_ITALIC and PANGO_WEIGHT_BOLD - where were actually compile constants for setting attributes and weren't recognized by Pango in a font string. (Whereas "Bold" and "Italic" are recognized).

Add RenderText test that checks that the width of a bold string > the width of a non-bold string.
Add FontList tests for the new functions.

BUG=107893
TEST=Run views_examples_exe "Text Styles" examples and try bold and italic styles (this depends on an unreleased CL). Also, new tests in FontListTest and RenderTextTest.

Review URL: http://codereview.chromium.org/8963027

TBR=asvitkine@chromium.org
Review URL: http://codereview.chromium.org/9147016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@116948 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 143 insertions, 279 deletions

diff --git a/ui/gfx/font_list.cc b/ui/gfx/font_list.cc
index 24bfde2..0101887 100644
--- a/ui/gfx/font_list.cc
+++ b/ui/gfx/font_list.cc
@@ -10,55 +10,6 @@
 #include "base/string_util.h"
 #include "ui/gfx/font_list.h"
 
-namespace {
-
-// Parses font description into |font_names|, |font_style| and |font_size|.
-void ParseFontDescriptionString(const std::string& font_description_string,
-                                std::vector<std::string>* font_names,
-                                int* font_style,
-                                int* font_size) {
-  base::SplitString(font_description_string, ',', font_names);
-  DCHECK_GT(font_names->size(), 1U);
-
-  // The last item is [STYLE_OPTIONS] SIZE.
-  std::vector<std::string> styles_size;
-  base::SplitString(font_names->back(), ' ', &styles_size);
-  DCHECK(!styles_size.empty());
-  base::StringToInt(styles_size.back(), font_size);
-  DCHECK_GT(*font_size, 0);
-  font_names->pop_back();
-
-  // Besides underline (which is supported through StyleRange), Font only
-  // supports BOLD and ITALIC, but not other styles.
-  *font_style = 0;
-  for (size_t i = 0; i < styles_size.size() - 1; ++i) {
-    // Styles are separated by white spaces. base::SplitString splits styles
-    // by space, and it inserts empty string for continuous spaces.
-    if (styles_size[i].empty())
-      continue;
-    if (!styles_size[i].compare("Bold"))
-      *font_style |= gfx::Font::BOLD;
-    else if (!styles_size[i].compare("Italic"))
-      *font_style |= gfx::Font::ITALIC;
-    else
-      NOTREACHED();
-  }
-}
-
-// Returns the font style and size as a string.
-std::string FontStyleAndSizeToString(int font_style, int font_size) {
-  std::string result;
-  if (font_style & gfx::Font::BOLD)
-    result += "Bold ";
-  if (font_style & gfx::Font::ITALIC)
-    result += "Italic ";
-  result += base::IntToString(font_size);
-  result += "px";
-  return result;
-}
-
-}  // namespace
-
 namespace gfx {
 
 FontList::FontList() {
@@ -92,38 +43,6 @@ FontList::FontList(const Font& font) {
 FontList::~FontList() {
 }
 
-FontList FontList::DeriveFontList(int font_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);
-    return FontList(fonts);
-  }
-
-  // Otherwise, parse the font description string to derive from it.
-  std::vector<std::string> font_names;
-  int old_style;
-  int font_size;
-  ParseFontDescriptionString(font_description_string_, &font_names,
-                             &old_style, &font_size);
-  std::string description = JoinString(font_names, ',');
-  description += "," + FontStyleAndSizeToString(font_style, font_size);
-  return FontList(description);
-}
-
-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;
-}
-
 const std::string& FontList::GetFontDescriptionString() const {
   if (font_description_string_.empty()) {
     DCHECK(!fonts_.empty());
@@ -133,8 +52,17 @@ const std::string& FontList::GetFontDescriptionString() const {
       font_description_string_ += ',';
     }
     // All fonts have the same style and size.
-    font_description_string_ +=
-        FontStyleAndSizeToString(fonts_[0].GetStyle(), fonts_[0].GetFontSize());
+    // TODO(xji): add style for Windows.
+#if defined(OS_LINUX)
+    int style = fonts_[0].GetStyle();
+    if (style & Font::BOLD)
+      font_description_string_ += "PANGO_WEIGHT_BOLD ";
+    if (style & Font::ITALIC)
+      font_description_string_ += "PANGO_STYLE_ITALIC ";
+#endif
+    int size = fonts_[0].GetFontSize();
+    font_description_string_ += base::IntToString(size);
+    font_description_string_ += "px";
   }
   return font_description_string_;
 }
@@ -143,19 +71,48 @@ 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);
-    for (size_t i = 0; i < font_names.size(); ++i) {
-      DCHECK(!font_names[i].empty());
+    std::vector<std::string> name_style_size;
+    base::SplitString(font_description_string_, ',', &name_style_size);
+    int item_count = static_cast<int>(name_style_size.size());
+    DCHECK_GT(item_count, 1);
+
+    // The last item is [STYLE_OPTIONS] SIZE.
+    std::vector<std::string> styles_size;
+    base::SplitString(name_style_size[item_count - 1], ' ', &styles_size);
+    DCHECK(!styles_size.empty());
+
+    int style = 0;
+    // TODO(xji): parse style for Windows.
+#if defined(OS_LINUX)
+    // Besides underline (which is supported through StyleRange), Font only
+    // supports BOLD and ITALIC styles, not other Pango styles.
+    for (size_t i = 0; i < styles_size.size() - 1; ++i) {
+      // Styles are separated by white spaces. base::SplitString splits styles
+      // by space, and it inserts empty string for continuous spaces.
+      if (styles_size[i].empty())
+        continue;
+      if (!styles_size[i].compare("PANGO_WEIGHT_BOLD"))
+        style |= Font::BOLD;
+      else if (!styles_size[i].compare("PANGO_STYLE_ITALIC"))
+        style |= Font::ITALIC;
+      else
+        NOTREACHED();
+    }
+#endif
+
+    std::string font_size = styles_size[styles_size.size() - 1];
+    int size_in_pixels;
+    base::StringToInt(font_size, &size_in_pixels);
+    DCHECK_GT(size_in_pixels, 0);
+
+    for (int i = 0; i < item_count - 1; ++i) {
+      DCHECK(!name_style_size[i].empty());
 
-      Font font(font_names[i], font_size);
-      if (font_style == Font::NORMAL)
+      Font font(name_style_size[i], size_in_pixels);
+      if (style == Font::NORMAL)
         fonts_.push_back(font);
       else
-        fonts_.push_back(font.DeriveFont(0, font_style));
+        fonts_.push_back(font.DeriveFont(0, style));
     }
   }
   return fonts_;
diff --git a/ui/gfx/font_list.h b/ui/gfx/font_list.h
index 5391d08..757d8cf 100644
--- a/ui/gfx/font_list.h
+++ b/ui/gfx/font_list.h
@@ -52,12 +52,6 @@ class UI_EXPORT FontList {
 
   ~FontList();
 
-  // Returns a new FontList with the given |font_style| flags.
-  FontList DeriveFontList(int font_style) const;
-
-  // Returns the |gfx::Font::FontStyle| style flags for this font list.
-  int GetFontStyle() const;
-
   // Returns a string representing font names, styles, and size. If the FontList
   // is initialized by a vector of Font, use the first font's style and size
   // for the description.
diff --git a/ui/gfx/font_list_unittest.cc b/ui/gfx/font_list_unittest.cc
index 4b88afb..342de96 100644
--- a/ui/gfx/font_list_unittest.cc
+++ b/ui/gfx/font_list_unittest.cc
@@ -7,26 +7,8 @@
 #include <string>
 #include <vector>
 
-#include "base/string_number_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace {
-
-// Helper function for comparing fonts for equality.
-std::string FontToString(const gfx::Font& font) {
-  std::string font_string = font.GetFontName();
-  font_string += "|";
-  font_string += base::IntToString(font.GetFontSize());
-  int style = font.GetStyle();
-  if (style & gfx::Font::BOLD)
-    font_string += "|bold";
-  if (style & gfx::Font::ITALIC)
-    font_string += "|italic";
-  return font_string;
-}
-
-}  // namespace
-
 namespace gfx {
 
 typedef testing::Test FontListTest;
@@ -50,10 +32,20 @@ TEST_F(FontListTest, FontDescString_FromFontWithNonNormalStyle) {
   // Test init from Font with non-normal style.
   Font font("Arial", 8);
   FontList font_list = FontList(font.DeriveFont(2, Font::BOLD));
-  EXPECT_EQ("Arial,Bold 10px", font_list.GetFontDescriptionString());
+  const std::string& font_str = font_list.GetFontDescriptionString();
+#if defined(OS_LINUX)
+  EXPECT_EQ("Arial,PANGO_WEIGHT_BOLD 10px", font_str);
+#else
+  EXPECT_EQ("Arial,10px", font_str);
+#endif
 
   font_list = FontList(font.DeriveFont(-2, Font::ITALIC));
-  EXPECT_EQ("Arial,Italic 6px", font_list.GetFontDescriptionString());
+  const std::string& font_str_1 = font_list.GetFontDescriptionString();
+#if defined(OS_LINUX)
+  EXPECT_EQ("Arial,PANGO_STYLE_ITALIC 6px", font_str_1);
+#else
+  EXPECT_EQ("Arial,6px", font_str_1);
+#endif
 }
 
 TEST_F(FontListTest, FontDescString_FromFontVector) {
@@ -65,7 +57,11 @@ TEST_F(FontListTest, FontDescString_FromFontVector) {
   fonts.push_back(font_1.DeriveFont(-2, Font::BOLD));
   FontList font_list = FontList(fonts);
   const std::string& font_str = font_list.GetFontDescriptionString();
-  EXPECT_EQ("Arial,Sans serif,Bold 8px", font_str);
+#if defined(OS_LINUX)
+  EXPECT_EQ("Arial,Sans serif,PANGO_WEIGHT_BOLD 8px", font_str);
+#else
+  EXPECT_EQ("Arial,Sans serif,8px", font_str);
+#endif
 }
 
 TEST_F(FontListTest, Fonts_FromDescString) {
@@ -73,8 +69,12 @@ TEST_F(FontListTest, Fonts_FromDescString) {
   FontList font_list = FontList("serif,Sans serif, 13px");
   const std::vector<Font>& fonts = font_list.GetFonts();
   EXPECT_EQ(2U, fonts.size());
-  EXPECT_EQ("serif|13", FontToString(fonts[0]));
-  EXPECT_EQ("Sans serif|13", FontToString(fonts[1]));
+  EXPECT_EQ("serif", fonts[0].GetFontName());
+  EXPECT_EQ(13, fonts[0].GetFontSize());
+  EXPECT_EQ(Font::NORMAL, fonts[0].GetStyle());
+  EXPECT_EQ("Sans serif", fonts[1].GetFontName());
+  EXPECT_EQ(13, fonts[1].GetFontSize());
+  EXPECT_EQ(Font::NORMAL, fonts[1].GetStyle());
 }
 
 TEST_F(FontListTest, Fonts_FromDescStringInFlexibleFormat) {
@@ -82,18 +82,34 @@ TEST_F(FontListTest, Fonts_FromDescStringInFlexibleFormat) {
   FontList font_list = FontList("  serif   ,   Sans serif ,   13px");
   const std::vector<Font>& fonts = font_list.GetFonts();
   EXPECT_EQ(2U, fonts.size());
-  EXPECT_EQ("serif|13", FontToString(fonts[0]));
-  EXPECT_EQ("Sans serif|13", FontToString(fonts[1]));
+  EXPECT_EQ("serif", fonts[0].GetFontName());
+  EXPECT_EQ(13, fonts[0].GetFontSize());
+  EXPECT_EQ(Font::NORMAL, fonts[0].GetStyle());
+  EXPECT_EQ("Sans serif", fonts[1].GetFontName());
+  EXPECT_EQ(13, fonts[1].GetFontSize());
+  EXPECT_EQ(Font::NORMAL, fonts[1].GetStyle());
 }
 
 TEST_F(FontListTest, Fonts_FromDescStringWithStyleInFlexibleFormat) {
   // Test init from font name style size string with flexible format.
-  FontList font_list = FontList("  serif  ,  Sans serif ,  Bold   "
-                                "  Italic   13px");
+  FontList font_list = FontList("  serif  ,  Sans serif ,  PANGO_WEIGHT_BOLD   "
+                                "  PANGO_STYLE_ITALIC   13px");
   const std::vector<Font>& fonts = font_list.GetFonts();
   EXPECT_EQ(2U, fonts.size());
-  EXPECT_EQ("serif|13|bold|italic", FontToString(fonts[0]));
-  EXPECT_EQ("Sans serif|13|bold|italic", FontToString(fonts[1]));
+  EXPECT_EQ("serif", fonts[0].GetFontName());
+  EXPECT_EQ(13, fonts[0].GetFontSize());
+#if defined(OS_LINUX)
+  EXPECT_EQ(Font::BOLD | Font::ITALIC, fonts[0].GetStyle());
+#else
+  EXPECT_EQ(Font::NORMAL, fonts[0].GetStyle());
+#endif
+  EXPECT_EQ("Sans serif", fonts[1].GetFontName());
+  EXPECT_EQ(13, fonts[1].GetFontSize());
+#if defined(OS_LINUX)
+  EXPECT_EQ(Font::BOLD | Font::ITALIC, fonts[1].GetStyle());
+#else
+  EXPECT_EQ(Font::NORMAL, fonts[1].GetStyle());
+#endif
 }
 
 TEST_F(FontListTest, Fonts_FromFont) {
@@ -102,21 +118,27 @@ TEST_F(FontListTest, Fonts_FromFont) {
   FontList font_list = FontList(font);
   const std::vector<Font>& fonts = font_list.GetFonts();
   EXPECT_EQ(1U, fonts.size());
-  EXPECT_EQ("Arial|8", FontToString(fonts[0]));
+  EXPECT_EQ("Arial", fonts[0].GetFontName());
+  EXPECT_EQ(8, fonts[0].GetFontSize());
+  EXPECT_EQ(Font::NORMAL, fonts[0].GetStyle());
 }
 
 TEST_F(FontListTest, Fonts_FromFontWithNonNormalStyle) {
   // Test init from Font with non-normal style.
   Font font("Arial", 8);
   FontList font_list = FontList(font.DeriveFont(2, Font::BOLD));
-  std::vector<Font> fonts = font_list.GetFonts();
+  const std::vector<Font>& fonts = font_list.GetFonts();
   EXPECT_EQ(1U, fonts.size());
-  EXPECT_EQ("Arial|10|bold", FontToString(fonts[0]));
+  EXPECT_EQ("Arial", fonts[0].GetFontName());
+  EXPECT_EQ(10, fonts[0].GetFontSize());
+  EXPECT_EQ(Font::BOLD, fonts[0].GetStyle());
 
   font_list = FontList(font.DeriveFont(-2, Font::ITALIC));
-  fonts = font_list.GetFonts();
-  EXPECT_EQ(1U, fonts.size());
-  EXPECT_EQ("Arial|6|italic", FontToString(fonts[0]));
+  const std::vector<Font>& fonts_1 = font_list.GetFonts();
+  EXPECT_EQ(1U, fonts_1.size());
+  EXPECT_EQ("Arial", fonts_1[0].GetFontName());
+  EXPECT_EQ(6, fonts_1[0].GetFontSize());
+  EXPECT_EQ(Font::ITALIC, fonts_1[0].GetStyle());
 }
 
 TEST_F(FontListTest, Fonts_FromFontVector) {
@@ -129,21 +151,30 @@ TEST_F(FontListTest, Fonts_FromFontVector) {
   FontList font_list = FontList(input_fonts);
   const std::vector<Font>& fonts = font_list.GetFonts();
   EXPECT_EQ(2U, fonts.size());
-  EXPECT_EQ("Arial|8|bold", FontToString(fonts[0]));
-  EXPECT_EQ("Sans serif|8|bold", FontToString(fonts[1]));
+  EXPECT_EQ("Arial", fonts[0].GetFontName());
+  EXPECT_EQ(8, fonts[0].GetFontSize());
+  EXPECT_EQ(Font::BOLD, fonts[0].GetStyle());
+  EXPECT_EQ("Sans serif", fonts[1].GetFontName());
+  EXPECT_EQ(8, fonts[1].GetFontSize());
+  EXPECT_EQ(Font::BOLD, fonts[1].GetStyle());
 }
 
 TEST_F(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");
+  FontList font_list = FontList("  serif  ,  Sans serif ,  PANGO_WEIGHT_BOLD   "
+                                "  PANGO_STYLE_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);
+#if defined(OS_LINUX)
+  EXPECT_EQ("serif,Sans serif,PANGO_WEIGHT_BOLD PANGO_STYLE_ITALIC 13px",
+            desc_str);
+#else
+  EXPECT_EQ("serif,Sans serif,13px", desc_str);
+#endif
 }
 
 TEST_F(FontListTest, Fonts_FontVector_RoundTrip) {
@@ -160,56 +191,18 @@ TEST_F(FontListTest, Fonts_FontVector_RoundTrip) {
   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_F(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_F(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].DeriveFont(0, Font::ITALIC | Font::BOLD);
-  fonts[1] = fonts[1].DeriveFont(0, Font::ITALIC | Font::BOLD);
-  font_list = FontList(fonts);
-  EXPECT_EQ(Font::ITALIC | Font::BOLD, font_list.GetFontStyle());
-}
-
-TEST_F(FontListTest, FontDescString_DeriveFontList) {
-  FontList font_list = FontList("Arial,Sans serif, 8px");
-
-  FontList derived = font_list.DeriveFontList(Font::BOLD | Font::ITALIC);
-  EXPECT_EQ("Arial,Sans serif,Bold Italic 8px",
-            derived.GetFontDescriptionString());
-}
-
-TEST_F(FontListTest, Fonts_DeriveFontList) {
-  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.DeriveFontList(Font::BOLD | Font::ITALIC);
-  const std::vector<Font>& derived_fonts = derived.GetFonts();
-
-  EXPECT_EQ(2U, derived_fonts.size());
-  EXPECT_EQ("Arial|8|bold|italic", FontToString(derived_fonts[0]));
-  EXPECT_EQ("Sans serif|8|bold|italic", FontToString(derived_fonts[1]));
+  EXPECT_EQ("Arial", round_trip_fonts[0].GetFontName());
+  EXPECT_EQ(8, round_trip_fonts[0].GetFontSize());
+  EXPECT_EQ("Sans serif", round_trip_fonts[1].GetFontName());
+  EXPECT_EQ(8, round_trip_fonts[1].GetFontSize());
+#if defined(OS_LINUX)
+  EXPECT_EQ(Font::BOLD, round_trip_fonts[0].GetStyle());
+  EXPECT_EQ(Font::BOLD, round_trip_fonts[1].GetStyle());
+#else
+  // Style is ignored.
+  EXPECT_EQ(Font::NORMAL, round_trip_fonts[0].GetStyle());
+  EXPECT_EQ(Font::NORMAL, round_trip_fonts[1].GetStyle());
+#endif
 }
 
 }  // namespace gfx
diff --git a/ui/gfx/render_text.cc b/ui/gfx/render_text.cc
index 4695245..d058501 100644
--- a/ui/gfx/render_text.cc
+++ b/ui/gfx/render_text.cc
@@ -77,16 +77,6 @@ void ApplyStyleRangeImpl(gfx::StyleRanges* style_ranges,
   style_ranges->insert(i, style_range);
 }
 
-// Converts |gfx::Font::FontStyle| flags to |SkTypeface::Style| flags.
-SkTypeface::Style ConvertFontStyleToSkiaTypefaceStyle(int font_style) {
-  int skia_style = SkTypeface::kNormal;
-  if (font_style & gfx::Font::BOLD)
-    skia_style |= SkTypeface::kBold;
-  if (font_style & gfx::Font::ITALIC)
-    skia_style |= SkTypeface::kItalic;
-  return static_cast<SkTypeface::Style>(skia_style);
-}
-
 }  // namespace
 
 namespace gfx {
@@ -114,26 +104,10 @@ void SkiaTextRenderer::SetTextSize(int size) {
   paint_.setTextSize(size);
 }
 
-void SkiaTextRenderer::SetFontStyle(int style) {
-  SkTypeface::Style skia_style = ConvertFontStyleToSkiaTypefaceStyle(style);
-  SkTypeface* current_typeface = paint_.getTypeface();
-
-  if (current_typeface->style() == skia_style)
-    return;
-
-  SkAutoTUnref<SkTypeface> typeface(
-      SkTypeface::CreateFromTypeface(current_typeface, skia_style));
-  if (typeface.get()) {
-    // |paint_| adds its own ref. So don't |release()| it from the ref ptr here.
-    SetTypeface(typeface.get());
-  }
-}
-
 void SkiaTextRenderer::SetFont(const gfx::Font& font) {
-  SkTypeface::Style skia_style =
-      ConvertFontStyleToSkiaTypefaceStyle(font.GetStyle());
   SkAutoTUnref<SkTypeface> typeface(
-      SkTypeface::CreateFromName(font.GetFontName().c_str(), skia_style));
+      SkTypeface::CreateFromName(font.GetFontName().c_str(),
+                                 SkTypeface::kNormal));
   if (typeface.get()) {
     // |paint_| adds its own ref. So don't |release()| it from the ref ptr here.
     SetTypeface(typeface.get());
@@ -190,7 +164,6 @@ void SkiaTextRenderer::DrawDecorations(int x, int y, int width,
 
 StyleRange::StyleRange()
     : foreground(SK_ColorBLACK),
-      font_style(gfx::Font::NORMAL),
       strike(false),
       underline(false) {
 }
diff --git a/ui/gfx/render_text.h b/ui/gfx/render_text.h
index 217f846..2a69ed0 100644
--- a/ui/gfx/render_text.h
+++ b/ui/gfx/render_text.h
@@ -39,13 +39,13 @@ class SkiaTextRenderer {
   void SetTypeface(SkTypeface* typeface);
   void SetTextSize(int size);
   void SetFont(const gfx::Font& font);
-  void SetFontStyle(int font_style);
   void SetForegroundColor(SkColor foreground);
   void DrawSelection(const std::vector<Rect>& selection, SkColor color);
   void DrawPosText(const SkPoint* pos,
                    const uint16* glyphs,
                    size_t glyph_count);
   void DrawDecorations(int x, int y, int width, bool underline, bool strike);
+  void DrawCursor(const gfx::Rect& bounds);
 
  private:
   SkCanvas* canvas_skia_;
@@ -70,9 +70,12 @@ const SkColor kCursorColor = SK_ColorBLACK;
 struct UI_EXPORT StyleRange {
   StyleRange();
 
+  // TODO(asvitkine): Add RenderText support for font weight. Add a |bold| style
+  // flag here, to be handled in RenderText's layout phase. For example, in
+  // RenderTextLinux, generate the new font description with font weight style
+  // option, create a Pango attribute from it, and append the attribute to
+  // layout.
   SkColor foreground;
-  // A gfx::Font::FontStyle flag to specify bold and italic styles.
-  int font_style;
   bool strike;
   bool underline;
   ui::Range range;
diff --git a/ui/gfx/render_text_linux.cc b/ui/gfx/render_text_linux.cc
index a51bbef..4ebac11 100644
--- a/ui/gfx/render_text_linux.cc
+++ b/ui/gfx/render_text_linux.cc
@@ -258,7 +258,6 @@ void RenderTextLinux::EnsureLayout() {
     // TODO(xji): If RenderText will be used for displaying purpose, such as
     // label, we will need to remove the single-line-mode setting.
     pango_layout_set_single_paragraph_mode(layout_, true);
-    SetupPangoAttributes(layout_);
 
     current_line_ = pango_layout_get_line_readonly(layout_, 0);
     pango_layout_line_ref(current_line_);
@@ -270,35 +269,6 @@ void RenderTextLinux::EnsureLayout() {
   }
 }
 
-void RenderTextLinux::SetupPangoAttributes(PangoLayout* layout) {
-  PangoAttrList* attrs = pango_attr_list_new();
-
-  int default_font_style = font_list().GetStyle();
-  for (StyleRanges::const_iterator i = style_ranges().begin();
-       i < style_ranges().end(); ++i) {
-    // In Pango, different fonts means different runs, and it breaks Arabic
-    // shaping across run boundaries. So, set font only when it is different
-    // from the default font.
-    // TODO(xji): We'll eventually need to split up StyleRange into components
-    // (ColorRange, FontRange, etc.) so that we can combine adjacent ranges
-    // with the same Fonts (to avoid unnecessarily splitting up runs).
-    if (i->font_style != default_font_style) {
-      FontList derived_font_list = font_list().DeriveFontList(i->font_style);
-      PangoFontDescription* desc = pango_font_description_from_string(
-          derived_font_list.GetFontDescriptionString().c_str());
-
-      PangoAttribute* pango_attr = pango_attr_font_desc_new(desc);
-      pango_attr->start_index = Utf16IndexToUtf8Index(i->range.start());
-      pango_attr->end_index = Utf16IndexToUtf8Index(i->range.end());
-      pango_attr_list_insert(attrs, pango_attr);
-      pango_font_description_free(desc);
-    }
-  }
-
-  pango_layout_set_attributes(layout, attrs);
-  pango_attr_list_unref(attrs);
-}
-
 void RenderTextLinux::DrawVisualText(Canvas* canvas) {
   TRACE_EVENT0("gfx", "RenderTextLinux::DrawVisualText");
   DCHECK(layout_);
@@ -383,7 +353,6 @@ void RenderTextLinux::DrawVisualText(Canvas* canvas) {
         //                  styles evenly over the glyph. We can do this too by
         //                  clipping and drawing the glyph several times.
         renderer.SetForegroundColor(styles[style].foreground);
-        renderer.SetFontStyle(styles[style].font_style);
         renderer.DrawPosText(&pos[start], &glyphs[start], i - start);
         if (styles[style].underline || styles[style].strike) {
           renderer.DrawDecorations(start_x, y, glyph_x - start_x,
@@ -403,7 +372,6 @@ void RenderTextLinux::DrawVisualText(Canvas* canvas) {
 
     // Draw the remaining glyphs.
     renderer.SetForegroundColor(styles[style].foreground);
-    renderer.SetFontStyle(styles[style].font_style);
     renderer.DrawPosText(&pos[start], &glyphs[start], glyph_count - start);
     if (styles[style].underline || styles[style].strike) {
        renderer.DrawDecorations(start_x, y, glyph_x - start_x,
diff --git a/ui/gfx/render_text_linux.h b/ui/gfx/render_text_linux.h
index 8b81a9a..8bb6cc5 100644
--- a/ui/gfx/render_text_linux.h
+++ b/ui/gfx/render_text_linux.h
@@ -78,9 +78,6 @@ class RenderTextLinux : public RenderText {
   // Unref |layout_| and |pango_line_|. Set them to NULL.
   void ResetLayout();
 
-  // Setup pango attribute: foreground, background, font, strike.
-  void SetupPangoAttributes(PangoLayout* layout);
-
   // Returns |run|'s visually previous run.
   // The complexity is O(n) since it is a single-linked list.
   PangoLayoutRun* GetPreviousRun(PangoLayoutRun* run) const;
diff --git a/ui/gfx/render_text_unittest.cc b/ui/gfx/render_text_unittest.cc
index 40f872b..bddfe3b8 100644
--- a/ui/gfx/render_text_unittest.cc
+++ b/ui/gfx/render_text_unittest.cc
@@ -865,22 +865,6 @@ TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
   EXPECT_EQ(6U, render_text->GetCursorPosition());
 }
 
-TEST_F(RenderTextTest, StringWidthTest) {
-  scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
-  render_text->SetText(UTF8ToUTF16("Hello World"));
-
-  // Check that width is valid
-  int width = render_text->GetStringWidth();
-  EXPECT_GT(width, 0);
-
-  // Apply a bold style and check that the new width is greater.
-  StyleRange bold;
-  bold.font_style |= gfx::Font::BOLD;
-  render_text->set_default_style(bold);
-  render_text->ApplyDefaultStyle();
-  EXPECT_GT(render_text->GetStringWidth(), width);
-}
-
 #endif
 
 }  // namespace gfx
diff --git a/ui/gfx/render_text_win.cc b/ui/gfx/render_text_win.cc
index d982c3d..b821a44 100644
--- a/ui/gfx/render_text_win.cc
+++ b/ui/gfx/render_text_win.cc
@@ -74,10 +74,7 @@ bool ChooseFallbackFont(HDC hdc,
     log_font.lfFaceName[0] = 0;
     EnumEnhMetaFile(0, meta_file, MetaFileEnumProc, &log_font, NULL);
     if (log_font.lfFaceName[0]) {
-      int font_style = font.GetStyle();
       *result = gfx::Font(UTF16ToUTF8(log_font.lfFaceName), font.GetFontSize());
-      if (result->GetStyle() != font_style)
-        *result = result->DeriveFont(0, font_style);
       found_fallback = true;
     }
   }
@@ -513,7 +510,7 @@ void RenderTextWin::ItemizeLogicalText() {
   for (int run_break = 0; run_break < text_length;) {
     internal::TextRun* run = new internal::TextRun();
     run->range.set_start(run_break);
-    run->font = GetFont().DeriveFont(0, style->font_style);
+    run->font = GetFont();
     run->foreground = style->foreground;
     run->strike = style->strike;
     run->underline = style->underline;
diff --git a/ui/gfx/render_text_win.h b/ui/gfx/render_text_win.h
index 4cbcb35..ac04c9f 100644
--- a/ui/gfx/render_text_win.h
+++ b/ui/gfx/render_text_win.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -27,8 +27,6 @@ struct TextRun {
   //            Otherwise, this breaks the glyph shaping process.
   //            See the example at: http://www.catch22.net/tuts/neatpad/12.
   SkColor foreground;
-  // A gfx::Font::FontStyle flag to specify bold and italic styles.
-  int font_style;
   bool strike;
   bool underline;