Reintroduce password support to NativeTextfieldViews

ui/gfx/render_text_linux.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/render_text_linux.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
+#include "base/utf_offset_string_conversions.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/pango_util.h"
-#include "unicode/uchar.h"
-#include "unicode/ustring.h"
 
 namespace gfx {
 
 namespace {
 
 // Returns the preceding element in a GSList (O(n)).
 GSList* GSListPrevious(GSList* head, GSList* item) {
   GSList* prev = NULL;
   for (GSList* cur = head; cur != item; cur = cur->next) {
     DCHECK(cur);
@@ skipping 21 matching lines @@
 // TODO(xji): index saved in upper layer is utf16 index. Pango uses utf8 index.
 // Since caret_pos is used internally, we could save utf8 index for caret_pos
 // to avoid conversion.
 
 RenderTextLinux::RenderTextLinux()
     : layout_(NULL),
       current_line_(NULL),
       log_attrs_(NULL),
       num_log_attrs_(0),
       layout_text_(NULL),
-      layout_text_len_(0) {
+      layout_text_len_(0),
+      last_text_index_(0),
+      last_layout_pointer_(NULL) {
 }
 
 RenderTextLinux::~RenderTextLinux() {
   ResetLayout();
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextLinux;
 }
 
@@ skipping 20 matching lines @@
     return SelectionModel(0, 0, SelectionModel::LEADING);
 
   Point p(ToTextPoint(point));
 
   // When the point is outside of text, return HOME/END position.
   if (p.x() < 0)
     return EdgeSelectionModel(CURSOR_LEFT);
   else if (p.x() > GetStringWidth())
     return EdgeSelectionModel(CURSOR_RIGHT);
 
-  int caret_pos, trailing;
+  int caret_pos_in_layout, trailing;

[msw, 2012/02/22 00:33:26]

Init these locals to 0, please.

[benrg, 2012/02/24 19:07:44]

I backed out all changes to this code; should I still change it?

   pango_layout_xy_to_index(layout_, p.x() * PANGO_SCALE, p.y() * PANGO_SCALE,
-                           &caret_pos, &trailing);
-
-  size_t selection_end = caret_pos;
-  if (trailing > 0) {
-    const char* ch = g_utf8_offset_to_pointer(layout_text_ + caret_pos,
-                                              trailing);
-    DCHECK_GE(ch, layout_text_);
-    DCHECK_LE(ch, layout_text_ + layout_text_len_);
-    selection_end = ch - layout_text_;
-  }
-
+                           &caret_pos_in_layout, &trailing);
+  size_t caret_pos = LayoutIndexToTextIndex(caret_pos_in_layout);
+  size_t selection_end = Utf16OffsetToIndex(text(), caret_pos, trailing);
+  DCHECK_LE(caret_pos, selection_end);
+  DCHECK_LE(selection_end, text().length());
   return SelectionModel(
-      Utf8IndexToUtf16Index(selection_end),
-      Utf8IndexToUtf16Index(caret_pos),
+      selection_end, caret_pos,

[msw, 2012/02/22 00:33:26]

|caret_pos| belongs on its own line.

       trailing > 0 ? SelectionModel::TRAILING : SelectionModel::LEADING);
 }
 
 Rect RenderTextLinux::GetCursorBounds(const SelectionModel& selection,
                                       bool insert_mode) {
   EnsureLayout();
 
   size_t caret_pos = insert_mode ? selection.caret_pos() :
                                    selection.selection_end();
   PangoRectangle pos;
-  pango_layout_index_to_pos(layout_, Utf16IndexToUtf8Index(caret_pos), &pos);
+  pango_layout_index_to_pos(layout_, TextIndexToLayoutIndex(caret_pos), &pos);
 
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   int x = pos.x;
   if ((insert_mode && caret_placement == SelectionModel::TRAILING) ||
       (!insert_mode && pos.width < 0))
     x += pos.width;
   x = PANGO_PIXELS(x);
 
   int h = std::min(display_rect().height(), PANGO_PIXELS(pos.height));
   Rect bounds(x, (display_rect().height() - h) / 2, 0, h);
@@ skipping 26 matching lines @@
 SelectionModel RenderTextLinux::AdjacentCharSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
   size_t caret = selection.caret_pos();
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   GSList* run = GetRunContainingPosition(caret);
   DCHECK(run);
 
   PangoLayoutRun* layout_run = reinterpret_cast<PangoLayoutRun*>(run->data);
   PangoItem* item = layout_run->item;
-  size_t run_start = Utf8IndexToUtf16Index(item->offset);
-  size_t run_end = Utf8IndexToUtf16Index(item->offset + item->length);
+  size_t run_start = LayoutIndexToTextIndex(item->offset);
+  size_t run_end = LayoutIndexToTextIndex(item->offset + item->length);
 
   if (!IsForwardMotion(direction, item)) {
     if (caret_placement == SelectionModel::TRAILING)
       return SelectionModel(caret, caret, SelectionModel::LEADING);
     else if (caret > run_start) {
       caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD);
       return SelectionModel(caret, caret, SelectionModel::LEADING);
     }
   } else {
     if (caret_placement == SelectionModel::LEADING) {
@@ skipping 15 matching lines @@
     return EdgeSelectionModel(direction);
 
   item = reinterpret_cast<PangoLayoutRun*>(adjacent_run->data)->item;
   return IsForwardMotion(direction, item) ?
       FirstSelectionModelInsideRun(item) : LastSelectionModelInsideRun(item);
 }
 
 SelectionModel RenderTextLinux::AdjacentWordSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
+  if (is_obscured())
+    return EdgeSelectionModel(direction);
+
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return selection;
 
   SelectionModel end = EdgeSelectionModel(direction);
   SelectionModel cur(selection);
   while (!cur.Equals(end)) {
     cur = AdjacentCharSelectionModel(cur, direction);
@@ skipping 14 matching lines @@
     VisualCursorDirection direction) {
   if (direction == GetVisualDirectionOfLogicalEnd()) {
     // Advance to the logical end of the text.
     GSList* run = current_line_->runs;
     if (direction == CURSOR_RIGHT)
       run = g_slist_last(run);
     if (run) {
       PangoLayoutRun* end_run = reinterpret_cast<PangoLayoutRun*>(run->data);
       PangoItem* item = end_run->item;
       if (IsForwardMotion(direction, item)) {
-        size_t caret = Utf8IndexToUtf16Index(
-            Utf8IndexOfAdjacentGrapheme(item->offset + item->length,
-                                        CURSOR_BACKWARD));
+        size_t caret = IndexOfAdjacentGrapheme(
+            LayoutIndexToTextIndex(item->offset + item->length),
+            CURSOR_BACKWARD);
         return SelectionModel(text().length(), caret, SelectionModel::TRAILING);
       } else {
-        size_t caret = Utf8IndexToUtf16Index(item->offset);
+        size_t caret = LayoutIndexToTextIndex(item->offset);
         return SelectionModel(text().length(), caret, SelectionModel::LEADING);
       }
     }
   }
   return SelectionModel(0, 0, SelectionModel::LEADING);
 }
 
 void RenderTextLinux::SetSelectionModel(const SelectionModel& model) {
   if (GetSelectionStart() != model.selection_start() ||
       GetCursorPosition() != model.selection_end()) {
@@ skipping 12 matching lines @@
 
   EnsureLayout();
 
   if (from == GetSelectionStart() && to == GetCursorPosition())
     return GetSelectionBounds();
   else
     return CalculateSubstringBounds(from, to);
 }
 
 bool RenderTextLinux::IsCursorablePosition(size_t position) {
-  if (position == 0 && text().empty())
+  if (position == 0)
     return true;
-
+  if (position > text().length())
+    return false;
   EnsureLayout();
-  return (position < static_cast<size_t>(num_log_attrs_) &&
-          log_attrs_[position].is_cursor_position);
+  return log_attrs_[Utf16IndexToOffset(text(), 0, position)].is_cursor_position;
 }
 
 void RenderTextLinux::UpdateLayout() {
   ResetLayout();
 }
 
 void RenderTextLinux::EnsureLayout() {
   if (layout_ == NULL) {
     CanvasSkia canvas(display_rect().size(), false);
     skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
     cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
 
     layout_ = pango_cairo_create_layout(cr);
     SetupPangoLayoutWithFontDescription(
         layout_,
-        text(),
+        GetDisplayText(),
         font_list().GetFontDescriptionString(),
         display_rect().width(),
         base::i18n::GetFirstStrongCharacterDirection(text()),
         CanvasSkia::DefaultCanvasTextAlignment());
 
     // No width set so that the x-axis position is relative to the start of the
     // text. ToViewPoint and ToTextPoint take care of the position conversion
     // between text space and view spaces.
     pango_layout_set_width(layout_, -1);
     // 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_);
 
     pango_layout_get_log_attrs(layout_, &log_attrs_, &num_log_attrs_);
 
     layout_text_ = pango_layout_get_text(layout_);
     layout_text_len_ = strlen(layout_text_);
+
+    last_text_index_ = 0;
+    last_layout_pointer_ = layout_text_;
+
+    SetupPangoAttributes(layout_);
   }
 }
 
 void RenderTextLinux::SetupPangoAttributes(PangoLayout* layout) {
   PangoAttrList* attrs = pango_attr_list_new();
 
   int default_font_style = font_list().GetFontStyle();
   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->start_index = TextIndexToLayoutIndex(i->range.start());
+      pango_attr->end_index = TextIndexToLayoutIndex(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) {
   DCHECK(layout_);
 
   Point offset(GetOriginForSkiaDrawing());
   SkScalar x = SkIntToScalar(offset.x());
   SkScalar y = SkIntToScalar(offset.y());
 
   std::vector<SkPoint> pos;
   std::vector<uint16> glyphs;
 
   StyleRanges styles(style_ranges());
   ApplyCompositionAndSelectionStyles(&styles);
 
-  // Pre-calculate UTF8 indices from UTF16 indices.
-  // TODO(asvitkine): Can we cache these?
-  std::vector<ui::Range> style_ranges_utf8;
-  style_ranges_utf8.reserve(styles.size());
-  size_t start_index = 0;
-  for (size_t i = 0; i < styles.size(); ++i) {
-    size_t end_index = Utf16IndexToUtf8Index(styles[i].range.end());
-    style_ranges_utf8.push_back(ui::Range(start_index, end_index));
-    start_index = end_index;
-  }

[xji, 2012/02/18 01:28:47]

will removing this cause performance hit if we do utf16 to utf8 conversion on
every glyph during constant redrawing (although last_text_index_ and
last_layout_pointer_ are cached)?

-
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
 
   for (GSList* it = current_line_->runs; it; it = it->next) {
     PangoLayoutRun* run = reinterpret_cast<PangoLayoutRun*>(it->data);
     int glyph_count = run->glyphs->num_glyphs;
     if (glyph_count == 0)
       continue;
 
     size_t run_start = run->item->offset;
-    size_t first_glyph_byte_index = run_start + run->glyphs->log_clusters[0];
+    size_t first_glyph_index =
+        LayoutIndexToTextIndex(run_start + run->glyphs->log_clusters[0]);
     size_t style_increment = IsForwardMotion(CURSOR_RIGHT, run->item) ? 1 : -1;
 
     // Find the initial style for this run.
     // TODO(asvitkine): Can we avoid looping here, e.g. by caching this per run?
     int style = -1;
-    for (size_t i = 0; i < style_ranges_utf8.size(); ++i) {
-      if (IndexInRange(style_ranges_utf8[i], first_glyph_byte_index)) {
+    for (size_t i = 0; i < styles.size(); ++i) {
+      if (IndexInRange(styles[i].range, first_glyph_index)) {
         style = i;
         break;
       }
     }
     DCHECK_GE(style, 0);
 
     PangoFontDescription* native_font =
         pango_font_describe(run->item->analysis.font);
 
     const char* family_name = pango_font_description_get_family(native_font);
@@ skipping 13 matching lines @@
 
     for (int i = 0; i < glyph_count; ++i) {
       const PangoGlyphInfo& glyph = run->glyphs->glyphs[i];
       glyphs[i] = static_cast<uint16>(glyph.glyph);
       pos[i].set(glyph_x + PANGO_PIXELS(glyph.geometry.x_offset),
                  y + PANGO_PIXELS(glyph.geometry.y_offset));
       glyph_x += PANGO_PIXELS(glyph.geometry.width);
 
       // If this glyph is beyond the current style, draw the glyphs so far and
       // advance to the next style.
-      size_t glyph_byte_index = run_start + run->glyphs->log_clusters[i];
+      size_t glyph_index =
+          LayoutIndexToTextIndex(run_start + run->glyphs->log_clusters[i]);
       DCHECK_GE(style, 0);
       DCHECK_LT(style, static_cast<int>(styles.size()));
-      if (!IndexInRange(style_ranges_utf8[style], glyph_byte_index)) {
+      if (!IndexInRange(styles[style].range, glyph_index)) {
         // TODO(asvitkine): For cases like "fi", where "fi" is a single glyph
         //                  but can span multiple styles, Pango splits the
         //                  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);
         renderer.DrawDecorations(start_x, y, glyph_x - start_x, styles[style]);
 
         start = i;
         start_x = glyph_x;
         // Loop to find the next style, in case the glyph spans multiple styles.
         do {
           style += style_increment;
         } while (style >= 0 && style < static_cast<int>(styles.size()) &&
-                 !IndexInRange(style_ranges_utf8[style], glyph_byte_index));
+                 !IndexInRange(styles[style].range, glyph_index));
       }
     }
 
     // Draw the remaining glyphs.
     renderer.SetForegroundColor(styles[style].foreground);
     renderer.SetFontStyle(styles[style].font_style);
     renderer.DrawPosText(&pos[start], &glyphs[start], glyph_count - start);
     renderer.DrawDecorations(start_x, y, glyph_x - start_x, styles[style]);
     x = glyph_x;
   }
 }
 
 size_t RenderTextLinux::IndexOfAdjacentGrapheme(
     size_t index,
     LogicalCursorDirection direction) {
   if (index > text().length())
     return text().length();
   EnsureLayout();
-  return Utf8IndexToUtf16Index(
-      Utf8IndexOfAdjacentGrapheme(Utf16IndexToUtf8Index(index), direction));
-}
 
-GSList* RenderTextLinux::GetRunContainingPosition(size_t position) const {
-  GSList* run = current_line_->runs;
-  while (run) {
-    PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
-    size_t run_start = Utf8IndexToUtf16Index(item->offset);
-    size_t run_end = Utf8IndexToUtf16Index(item->offset + item->length);
-
-    if (position >= run_start && position < run_end)
-      return run;
-    run = run->next;
-  }
-  return NULL;
-}
-
-size_t RenderTextLinux::Utf8IndexOfAdjacentGrapheme(
-    size_t utf8_index_of_current_grapheme,
-    LogicalCursorDirection direction) const {
-  const char* ch = layout_text_ + utf8_index_of_current_grapheme;
-  int char_offset = static_cast<int>(g_utf8_pointer_to_offset(layout_text_,
-                                                              ch));
-  int start_char_offset = char_offset;
+  ptrdiff_t char_offset = Utf16IndexToOffset(text(), 0, index);
   if (direction == CURSOR_BACKWARD) {
     if (char_offset > 0) {
       do {
         --char_offset;
       } while (char_offset > 0 && !log_attrs_[char_offset].is_cursor_position);
     }
   } else {  // direction == CURSOR_FORWARD
     if (char_offset < num_log_attrs_ - 1) {
       do {
         ++char_offset;
       } while (char_offset < num_log_attrs_ - 1 &&
                !log_attrs_[char_offset].is_cursor_position);
     }
   }
+  return Utf16OffsetToIndex(text(), 0, char_offset);
+}
 
-  ch = g_utf8_offset_to_pointer(ch, char_offset - start_char_offset);
-  return static_cast<size_t>(ch - layout_text_);
+GSList* RenderTextLinux::GetRunContainingPosition(size_t position) const {
+  position = TextIndexToLayoutIndex(position);
+  for (GSList* run = current_line_->runs; run; run = run->next) {
+    PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
+    if (position >= static_cast<size_t>(item->offset) &&
+        position < static_cast<size_t>(item->offset + item->length))
+      return run;
+  }
+  return NULL;

[xji, 2012/02/18 01:28:47]

Ah, nice!

 }
 
 SelectionModel RenderTextLinux::FirstSelectionModelInsideRun(
-    const PangoItem* item) const {
-  size_t caret = Utf8IndexToUtf16Index(item->offset);
-  size_t cursor = Utf8IndexToUtf16Index(
-      Utf8IndexOfAdjacentGrapheme(item->offset, CURSOR_FORWARD));
+    const PangoItem* item) {
+  size_t caret = LayoutIndexToTextIndex(item->offset);
+  size_t cursor = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD);
   return SelectionModel(cursor, caret, SelectionModel::TRAILING);
 }
 
 SelectionModel RenderTextLinux::LastSelectionModelInsideRun(
-    const PangoItem* item) const {
-  size_t caret = Utf8IndexToUtf16Index(Utf8IndexOfAdjacentGrapheme(
-      item->offset + item->length, CURSOR_BACKWARD));
+    const PangoItem* item) {
+  size_t caret = IndexOfAdjacentGrapheme(
+      LayoutIndexToTextIndex(item->offset + item->length), CURSOR_BACKWARD);
   return SelectionModel(caret, caret, SelectionModel::LEADING);
 }
 
 void RenderTextLinux::ResetLayout() {
   // set_cached_bounds_and_offset_valid(false) is done in RenderText for every
   // operation that triggers ResetLayout().
   if (layout_) {
     g_object_unref(layout_);
     layout_ = NULL;
   }
   if (current_line_) {
     pango_layout_line_unref(current_line_);
     current_line_ = NULL;
   }
   if (log_attrs_) {
     g_free(log_attrs_);
     log_attrs_ = NULL;
     num_log_attrs_ = 0;
   }
   if (!selection_visual_bounds_.empty())
     selection_visual_bounds_.clear();
   layout_text_ = NULL;
   layout_text_len_ = 0;
+  last_text_index_ = 0;
+  last_layout_pointer_ = NULL;
 }
 
-size_t RenderTextLinux::Utf16IndexToUtf8Index(size_t index) const {
-  int32_t utf8_index = 0;
-  UErrorCode ec = U_ZERO_ERROR;
-  u_strToUTF8(NULL, 0, &utf8_index, text().data(), index, &ec);
-  // Even given a destination buffer as NULL and destination capacity as 0,
-  // if the output length is equal to or greater than the capacity, then the
-  // UErrorCode is set to U_STRING_NOT_TERMINATED_WARNING or
-  // U_BUFFER_OVERFLOW_ERROR respectively.
-  // Please refer to
-  // http://userguide.icu-project.org/strings#TOC-Using-C-Strings:-NUL-Terminated-vs
-  // for detail (search for "Note that" below "Preflighting").
-  DCHECK(ec == U_BUFFER_OVERFLOW_ERROR ||
-         ec == U_STRING_NOT_TERMINATED_WARNING);
-  return utf8_index;
+size_t RenderTextLinux::TextIndexToLayoutIndex(size_t text_index) const {
+  // If the text is obscured then |layout_text_| is not the same as |text()|,
+  // but whether or not the text is obscured, the character (code point) offset
+  // in |layout_text_| is the same as that in |text()|.
+  DCHECK(layout_);
+  ptrdiff_t offset = Utf16IndexToOffset(text(), last_text_index_, text_index);
+  const char* layout_pointer = g_utf8_offset_to_pointer(last_layout_pointer_,
+                                                        offset);
+  last_text_index_ = text_index;
+  last_layout_pointer_ = layout_pointer;
+  return (layout_pointer - layout_text_);
 }
 
-size_t RenderTextLinux::Utf8IndexToUtf16Index(size_t index) const {
-  int32_t utf16_index = 0;
-  UErrorCode ec = U_ZERO_ERROR;
-  u_strFromUTF8(NULL, 0, &utf16_index, layout_text_, index, &ec);
-  DCHECK(ec == U_BUFFER_OVERFLOW_ERROR ||
-         ec == U_STRING_NOT_TERMINATED_WARNING);
-  return utf16_index;
+size_t RenderTextLinux::LayoutIndexToTextIndex(size_t layout_index) const {
+  // See |TextIndexToLayoutIndex()|.
+  DCHECK(layout_);
+  const char* layout_pointer = layout_text_ + layout_index;
+  glong offset = g_utf8_pointer_to_offset(last_layout_pointer_, layout_pointer);
+  size_t text_index = Utf16OffsetToIndex(text(), last_text_index_, offset);
+  last_text_index_ = text_index;
+  last_layout_pointer_ = layout_pointer;
+  return text_index;
 }
 
 std::vector<Rect> RenderTextLinux::CalculateSubstringBounds(size_t from,
                                                             size_t to) {
   int* ranges;
   int n_ranges;
-  size_t from_in_utf8 = Utf16IndexToUtf8Index(from);
-  size_t to_in_utf8 = Utf16IndexToUtf8Index(to);
+  size_t from_in_utf8 = TextIndexToLayoutIndex(from);
+  size_t to_in_utf8 = TextIndexToLayoutIndex(to);
   pango_layout_line_get_x_ranges(
       current_line_,
       std::min(from_in_utf8, to_in_utf8),
       std::max(from_in_utf8, to_in_utf8),
       &ranges,
       &n_ranges);
 
   int height;
   pango_layout_get_pixel_size(layout_, NULL, &height);
 
@@ skipping 12 matching lines @@
 }
 
 std::vector<Rect> RenderTextLinux::GetSelectionBounds() {
   if (selection_visual_bounds_.empty())
     selection_visual_bounds_ =
         CalculateSubstringBounds(GetSelectionStart(), GetCursorPosition());
   return selection_visual_bounds_;
 }
 
 }  // namespace gfx