Replace StyleRange with BreakList; update RenderText, etc.

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 32 matching lines @@
 // The minimum distance between the top and bottom of the {icon|text} and the
 // top or bottom of the row.
 const int kMinimumIconVerticalPadding = 2;
 const int kMinimumTextVerticalPadding = 3;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxResultView, public:
 
-// Precalculated data used to draw the portion of a match classification that
-// fits entirely within one run.
-struct OmniboxResultView::ClassificationData {
-  string16 text;
-  const gfx::Font* font;
-  SkColor color;
-  gfx::Size pixel_size;
-  gfx::RenderText* render_text;  // Weak.
-};
-
 // Precalculated data used to draw a complete visual run within the match.
-// This will include all or part of at leasdt one, and possibly several,
+// This will include all or part of at least one, and possibly several,
 // classifications.
 struct OmniboxResultView::RunData {
+  RunData() : run_start(0), visual_order(0), is_rtl(false), pixel_width(0) {}
+
   size_t run_start;  // Offset within the match text where this run begins.
   int visual_order;  // Where this run occurs in visual order.  The earliest
   // run drawn is run 0.
   bool is_rtl;
   int pixel_width;
-  Classifications classifications;  // Classification pieces within this run,
-                                    // in logical order.
+
+  // Styled text classification pieces within this run, in logical order.
+  Classifications classifications;
 };
 
 // This class is a utility class for calculations affected by whether the result
 // view is horizontally mirrored.  The drawing functions can be written as if
 // all drawing occurs left-to-right, and then use this class to get the actual
 // coordinates to begin drawing onscreen.
 class OmniboxResultView::MirroringContext {
  public:
   MirroringContext() : center_(0), right_(0) {}
 
@@ skipping 21 matching lines @@
  private:
   int center_;
   int right_;
 
   DISALLOW_COPY_AND_ASSIGN(MirroringContext);
 };
 
 OmniboxResultView::OmniboxResultView(
     OmniboxResultViewModel* model,
     int model_index,
-    const gfx::Font& font,
-    const gfx::Font& bold_font)
+    const gfx::Font& font)
     : edge_item_padding_(LocationBarView::GetItemPadding()),
       item_padding_(LocationBarView::GetItemPadding()),
       minimum_text_vertical_padding_(kMinimumTextVerticalPadding),
       model_(model),
       model_index_(model_index),
-      normal_font_(font),
-      bold_font_(bold_font),
+      font_(font),
+      font_height_(std::max(font.GetHeight(),
+                            font.DeriveFont(0, gfx::BOLD).GetHeight())),
       ellipsis_width_(font.GetStringWidth(string16(kEllipsis))),
       mirroring_context_(new MirroringContext()),
       keyword_icon_(new views::ImageView()),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           animation_(new ui::SlideAnimation(this))) {
   CHECK_GE(model_index, 0);
   if (default_icon_size_ == 0) {
     default_icon_size_ =
         ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         AutocompleteMatch::TypeToIcon(AutocompleteMatch::URL_WHAT_YOU_TYPED))->
@@ skipping 108 matching lines @@
         ACMatchClassification(0, ACMatchClassification::NONE));
     x = DrawString(canvas, separator, classifications, true, x,
                    text_bounds_.y());
 
     DrawString(canvas, match.description, match.description_class, true, x,
                text_bounds_.y());
   }
 }
 
 int OmniboxResultView::GetTextHeight() const {
-  return std::max(normal_font_.GetHeight(), bold_font_.GetHeight());
+  return font_height_;
 }
 
 // static
 void OmniboxResultView::CommonInitColors(const ui::NativeTheme* theme,
                                          SkColor colors[][NUM_KINDS]) {
   colors[HOVERED][BACKGROUND] =
       color_utils::AlphaBlend(colors[SELECTED][BACKGROUND],
                               colors[NORMAL][BACKGROUND], 64);
   colors[HOVERED][TEXT] = colors[NORMAL][TEXT];
 #if defined(USE_AURA)
@@ skipping 130 matching lines @@
       const size_t text_start =
           std::max(classifications[i].offset, current_run->run_start);
       if (text_start >= run_end)
         break;  // We're past the last classification in the run.
 
       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.
 
-      current_run->classifications.push_back(ClassificationData());
-      ClassificationData* current_data =
-          &current_run->classifications.back();
-      current_data->text = text.substr(text_start, text_end - text_start);
+      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_);
 
       // Calculate style-related data.
-      const int style = classifications[i].style;
-      const bool use_bold_font = !!(style & ACMatchClassification::MATCH);
-      current_data->font = &(use_bold_font ? bold_font_ : normal_font_);
+      if (classifications[i].style & ACMatchClassification::MATCH)
+        render_text->SetStyle(gfx::BOLD, true);
       const ResultViewState state = GetState();
-      if (style & ACMatchClassification::URL)
-        current_data->color = GetColor(state, URL);
-      else if (style & ACMatchClassification::DIM)
-        current_data->color = GetColor(state, DIMMED_TEXT);
+      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
-        current_data->color = GetColor(state, force_dim ? DIMMED_TEXT : TEXT);
+        render_text->SetColor(GetColor(state, force_dim ? DIMMED_TEXT : TEXT));
 
-      render_texts.push_back(gfx::RenderText::CreateInstance());
-      current_data->render_text = render_texts.back();
-      current_data->render_text->SetFont(*current_data->font);
-      current_data->render_text->SetText(current_data->text);
-
-      gfx::StyleRange style_range;
-      style_range.foreground = current_data->color;
-      style_range.font_style = current_data->font->GetStyle();
-      current_data->render_text->set_default_style(style_range);
-      current_data->render_text->ApplyDefaultStyle();
-
-      current_data->pixel_size = current_data->render_text->GetStringSize();
-      current_run->pixel_width += current_data->pixel_size.width();
+      current_run->pixel_width += render_text->GetStringSize().width();
     }
     DCHECK(!current_run->classifications.empty());
   }
   DCHECK(!runs.empty());
 
   // Sort into logical order so we can elide logically.
   std::sort(runs.begin(), runs.end(), &SortRunsLogically);
 
   // Now determine what to elide, if anything.  Several subtle points:
   //   * Because we have the run data, we can get edge cases correct, like
   //     whether to place an ellipsis before or after the end of a run when the
   //     text needs to be elided at the run boundary.
   //   * The "or one before it" comments below refer to cases where an earlier
   //     classification fits completely, but leaves too little space for an
   //     ellipsis that turns out to be needed later.  These cases are commented
   //     more completely in Elide().
   int remaining_width = mirroring_context_->remaining_width(x);
   for (Runs::iterator i(runs.begin()); i != runs.end(); ++i) {
     if (i->pixel_width > remaining_width) {
       // This run or one before it needs to be elided.
       for (Classifications::iterator j(i->classifications.begin());
            j != i->classifications.end(); ++j) {
-        if (j->pixel_size.width() > remaining_width) {
+        const int width = (*j)->GetStringSize().width();
+        if (width > remaining_width) {
           // This classification or one before it needs to be elided.  Erase all
           // further classifications and runs so Elide() can simply reverse-
           // iterate over everything to find the specific classification to
           // elide.
           i->classifications.erase(++j, i->classifications.end());
           runs.erase(++i, runs.end());
           Elide(&runs, remaining_width);
           break;
         }
-        remaining_width -= j->pixel_size.width();
+        remaining_width -= width;
       }
       break;
     }
     remaining_width -= i->pixel_width;
   }
 
   // Sort back into visual order so we can display the runs correctly.
   std::sort(runs.begin(), runs.end(), &SortRunsVisually);
 
   // Draw the runs.
   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 int left =
-          mirroring_context_->mirrored_left_coord(x, x + j->pixel_size.width());
+      const gfx::Size size = (*j)->GetStringSize();
       // Align the text runs to a common baseline.
-      const int top =
-          y + normal_font_.GetBaseline() - j->render_text->GetBaseline();
-      gfx::Rect rect(left, top, j->pixel_size.width(), j->pixel_size.height());
-      j->render_text->SetDisplayRect(rect);
-      j->render_text->Draw(canvas);
-      x += j->pixel_size.width();
+      const gfx::Rect rect(
+          mirroring_context_->mirrored_left_coord(x, x + size.width()),
+          y + font_.GetBaseline() - (*j)->GetBaseline(),
+          size.width(), size.height());
+      (*j)->SetDisplayRect(rect);
+      (*j)->Draw(canvas);
+      x += size.width();
     }
   }
 
   return x;
 }
 
 void OmniboxResultView::Elide(Runs* runs, int remaining_width) const {
   // The complexity of this function is due to edge cases like the following:
   // We have 100 px of available space, an initial classification that takes 86
   // px, and a font that has a 15 px wide ellipsis character.  Now if the first
   // classification is followed by several very narrow classifications (e.g. 3
   // px wide each), we don't know whether we need to elide or not at the time we
   // see the first classification -- it depends on how many subsequent
   // classifications follow, and some of those may be in the next run (or
   // several runs!).  This is why instead we let our caller move forward until
   // we know we definitely need to elide, and then in this function we move
   // backward again until we find a string that we can successfully do the
   // eliding on.
   bool first_classification = true;
   for (Runs::reverse_iterator i(runs->rbegin()); i != runs->rend(); ++i) {
     for (Classifications::reverse_iterator j(i->classifications.rbegin());
          j != i->classifications.rend(); ++j) {
       if (!first_classification) {
+        // We also add this classification's width (sans ellipsis) back to the
+        // available width since we want to consider the available space we'll
+        // have when we draw this classification.
+        remaining_width += (*j)->GetStringSize().width();
+
         // 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->text += kEllipsis;
-        j->render_text->SetText(j->text);
-
-        // We also add this classification's width (sans ellipsis) back to the
-        // available width since we want to consider the available space we'll
-        // have when we draw this classification.
-        remaining_width += j->pixel_size.width();
+        (*j)->SetText((*j)->text() + kEllipsis);
       }
       first_classification = false;
 
       // Can we fit at least an ellipsis?
-      string16 elided_text =
-          ui::ElideText(j->text, *j->font, remaining_width, ui::ELIDE_AT_END);
-      Classifications::reverse_iterator prior_classification(j);
-      ++prior_classification;
-      const bool on_first_classification =
-        (prior_classification == i->classifications.rend());
+      string16 elided_text = ui::ElideText((*j)->text(), (*j)->GetFont(),
+                                           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
         // location (if the previous run is reversed from the normal visual
         // order).
         // NOTE: If this isn't the first classification in the run, we don't
         // need to bother with this; see note below.
         elided_text = kEllipsis;
       }
       if (!elided_text.empty()) {
         // Success.  Elide this classification and stop.
-        j->text = elided_text;
+        (*j)->SetText(elided_text);
 
         // If we could only fit an ellipsis, then only make it bold if there was
         // an immediate prior classification in this run that was also bold, or
         // it will look orphaned.
-        if ((j->font != &normal_font_) && (elided_text.length() == 1) &&
+        if ((((*j)->GetFont().GetStyle() & gfx::BOLD) != 0) &&
+            (elided_text.length() == 1) &&
             (on_first_classification ||
-             (prior_classification->font == &normal_font_))) {
-          j->font = &normal_font_;
-          j->render_text->SetFont(*j->font);
+             (((*prior)->GetFont().GetStyle() & gfx::BOLD) == 0))) {
+          (*j)->SetStyle(gfx::BOLD, false);
         }
 
-        j->render_text->SetText(elided_text);
-        j->pixel_size = j->render_text->GetStringSize();
-
         // Erase any other classifications that come after the elided one.
         i->classifications.erase(j.base(), i->classifications.end());
         runs->erase(i.base(), runs->end());
         return;
       }
 
       // We couldn't fit an ellipsis.  Move back one classification,
       // append an ellipsis, and try again.
       // NOTE: In the edge case that a bold ellipsis doesn't fit but a
       // normal one would, and we reach here, then there is a previous
@@ skipping 68 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();
 }