Supports FontList in Textfield.

chrome/browser/ui/views/omnibox/omnibox_result_view.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.
 
 // For WinDDK ATL compatibility, these ATL headers must come first.
 #include "build/build_config.h"
 #if defined(OS_WIN)
 #include <atlbase.h>  // NOLINT
 #include <atlwin.h>  // NOLINT
 #endif
@@ skipping 89 matching lines @@
   int center_;
   int right_;
 
   DISALLOW_COPY_AND_ASSIGN(MirroringContext);
 };
 
 OmniboxResultView::OmniboxResultView(
     OmniboxResultViewModel* model,
     int model_index,
     LocationBarView* location_bar_view,
-    const gfx::Font& font)
+    const gfx::FontList& font_list)
     : edge_item_padding_(LocationBarView::GetItemPadding()),
       item_padding_(LocationBarView::GetItemPadding()),
       minimum_text_vertical_padding_(kMinimumTextVerticalPadding),
       model_(model),
       model_index_(model_index),
       location_bar_view_(location_bar_view),
-      font_(font),
-      font_height_(std::max(font.GetHeight(),
-                            font.DeriveFont(0, gfx::BOLD).GetHeight())),
-      ellipsis_width_(font.GetStringWidth(string16(kEllipsis))),
+      font_list_(font_list),
+      font_height_(std::max(font_list.GetHeight(),
+                            font_list.DeriveFontList(gfx::BOLD).GetHeight())),
+      ellipsis_width_(font_list.GetPrimaryFont().GetStringWidth(
+          string16(kEllipsis))),
       mirroring_context_(new MirroringContext()),
       keyword_icon_(new views::ImageView()),
       animation_(new ui::SlideAnimation(this)) {
   CHECK_GE(model_index, 0);
   if (default_icon_size_ == 0) {
     default_icon_size_ =
         location_bar_view_->GetThemeProvider()->GetImageSkiaNamed(
             AutocompleteMatch::TypeToIcon(
                 AutocompleteMatchType::URL_WHAT_YOU_TYPED))->width();
   }
@@ skipping 265 matching lines @@
 
       const size_t text_end = (i < (classifications.size() - 1)) ?
           std::min(classifications[i + 1].offset, run_end) : run_end;
       if (text_end <= current_run->run_start)
         continue;  // We haven't reached the first classification in the run.
 
       render_texts.push_back(gfx::RenderText::CreateInstance());
       gfx::RenderText* render_text = render_texts.back();
       current_run->classifications.push_back(render_text);
       render_text->SetText(text.substr(text_start, text_end - text_start));
-      render_text->SetFont(font_);
+      render_text->SetFontList(font_list_);
 
       // Calculate style-related data.
       if (classifications[i].style & ACMatchClassification::MATCH)
         render_text->SetStyle(gfx::BOLD, true);
       const ResultViewState state = GetState();
       if (classifications[i].style & ACMatchClassification::URL)
         render_text->SetColor(GetColor(state, URL));
       else if (classifications[i].style & ACMatchClassification::DIM)
         render_text->SetColor(GetColor(state, DIMMED_TEXT));
       else
@@ skipping 47 matching lines @@
   for (Runs::iterator i(runs.begin()); i != runs.end(); ++i) {
     const bool reverse_visible_order = (i->is_rtl != base::i18n::IsRTL());
     if (reverse_visible_order)
       std::reverse(i->classifications.begin(), i->classifications.end());
     for (Classifications::const_iterator j(i->classifications.begin());
          j != i->classifications.end(); ++j) {
       const gfx::Size size = (*j)->GetStringSize();
       // Align the text runs to a common baseline.
       const gfx::Rect rect(
           mirroring_context_->mirrored_left_coord(x, x + size.width()),
-          y + font_.GetBaseline() - (*j)->GetBaseline(),
+          y + font_list_.GetBaseline() - (*j)->GetBaseline(),
           size.width(), size.height());
       (*j)->SetDisplayRect(rect);
       (*j)->Draw(canvas);
       x += size.width();
     }
   }
 
   return x;
 }
 
@@ skipping 21 matching lines @@
 
         // For all but the first classification we consider, we need to append
         // an ellipsis, since there isn't enough room to draw it after this
         // classification.
         (*j)->SetText((*j)->text() + kEllipsis);
       }
       first_classification = false;
 
       // Can we fit at least an ellipsis?
       gfx::Font font((*j)->GetStyle(gfx::BOLD) ?
-          (*j)->GetFont().DeriveFont(0, gfx::Font::BOLD) : (*j)->GetFont());
+          (*j)->GetPrimaryFont().DeriveFont(0, gfx::Font::BOLD) :
+          (*j)->GetPrimaryFont());
       string16 elided_text(
           ui::ElideText((*j)->text(), font, remaining_width, ui::ELIDE_AT_END));
       Classifications::reverse_iterator prior(j + 1);
       const bool on_first_classification = (prior == i->classifications.rend());
       if (elided_text.empty() && (remaining_width >= ellipsis_width_) &&
           on_first_classification) {
         // Edge case: This classification is bold, we can't fit a bold ellipsis
         // but we can fit a normal one, and this is the first classification in
         // the run.  We should display a lone normal ellipsis, because appending
         // one to the end of the previous run might put it in the wrong visual
@@ skipping 95 matching lines @@
     int x = GetMirroredXForRect(keyword_text_bounds_);
     mirroring_context_->Initialize(x, keyword_text_bounds_.width());
     PaintMatch(canvas, *match_.associated_keyword.get(), x);
   }
 }
 
 void OmniboxResultView::AnimationProgressed(const ui::Animation* animation) {
   Layout();
   SchedulePaint();
 }