Replace bare ICU run iterator with base::i18n::BiDiLineIterator

ui/gfx/render_text_harfbuzz.cc

 // Copyright 2014 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_harfbuzz.h"
 
 #include <map>
 
+#include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "third_party/harfbuzz-ng/src/hb.h"
 #include "third_party/icu/source/common/unicode/ubidi.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/utf16_indexing.h"
 
 #if defined(OS_WIN)
@@ skipping 302 matching lines @@
   return hb_script_from_string(uscript_getShortName(script), -1);
 }
 
 }  // namespace
 
 namespace internal {
 
 TextRunHarfBuzz::TextRunHarfBuzz()
     : width(0),
       preceding_run_widths(0),
-      direction(UBIDI_LTR),
+      is_rtl(false),
       level(0),
       script(USCRIPT_INVALID_CODE),
       glyph_count(-1),
       font_size(0),
       font_style(0),
       strike(false),
       diagonal_strike(false),
       underline(false) {}
 
 TextRunHarfBuzz::~TextRunHarfBuzz() {}
 
 size_t TextRunHarfBuzz::CharToGlyph(size_t pos) const {
   DCHECK(range.start() <= pos && pos < range.end());
 
-  if (direction == UBIDI_LTR) {
+  if (!is_rtl) {
     for (size_t i = 0; i < glyph_count - 1; ++i) {
       if (pos < glyph_to_char[i + 1])
         return i;
     }
     return glyph_count - 1;
   }
 
   for (size_t i = 0; i < glyph_count; ++i) {
     if (pos >= glyph_to_char[i])
       return i;
@@ skipping 22 matching lines @@
       return true;
   }
   return false;
 }
 
 int TextRunHarfBuzz::GetGlyphXBoundary(size_t text_index, bool trailing) const {
   int x = preceding_run_widths;
   Range glyph_range;
   if (text_index == range.end()) {
     trailing = true;
-    glyph_range = direction == UBIDI_LTR ?
-        Range(glyph_count - 1, glyph_count) : Range(0, 1);
+    glyph_range = is_rtl ? Range(0, 1) : Range(glyph_count - 1, glyph_count);
   } else {
     glyph_range = CharRangeToGlyphRange(Range(text_index, text_index + 1));
   }
   const int trailing_step = trailing ? 1 : 0;
-  const size_t glyph_pos = glyph_range.start() +
-      (direction == UBIDI_LTR ? trailing_step : (1 - trailing_step));
+  const size_t glyph_pos =
+      glyph_range.start() + (is_rtl ? (1 - trailing_step) : trailing_step);
   x += glyph_pos < glyph_count ?
       SkScalarRoundToInt(positions[glyph_pos].x()) : width;
   return x;
 }
 
 }  // namespace internal
 
 RenderTextHarfBuzz::RenderTextHarfBuzz()
     : RenderText(),
       needs_layout_(false) {}
@@ skipping 12 matching lines @@
   int offset = 0;
   size_t run_index = GetRunContainingXCoord(x, &offset);
   if (run_index >= runs_.size())
     return EdgeSelectionModel((x < 0) ? CURSOR_LEFT : CURSOR_RIGHT);
   const internal::TextRunHarfBuzz& run = *runs_[run_index];
 
   for (size_t i = 0; i < run.glyph_count; ++i) {
     const SkScalar end =
         i + 1 == run.glyph_count ? run.width : run.positions[i + 1].x();
     const SkScalar middle = (end + run.positions[i].x()) / 2;
-    const bool is_rtl = run.direction == UBIDI_RTL;
+
     if (offset < middle) {
       return SelectionModel(LayoutIndexToTextIndex(
-          run.glyph_to_char[i] + (is_rtl ? 1 : 0)),
-          (is_rtl ? CURSOR_BACKWARD : CURSOR_FORWARD));
+          run.glyph_to_char[i] + (run.is_rtl ? 1 : 0)),
+          (run.is_rtl ? CURSOR_BACKWARD : CURSOR_FORWARD));
     }
     if (offset < end) {
       return SelectionModel(LayoutIndexToTextIndex(
-          run.glyph_to_char[i] + (is_rtl ? 0 : 1)),
-          (is_rtl ? CURSOR_FORWARD : CURSOR_BACKWARD));
+          run.glyph_to_char[i] + (run.is_rtl ? 0 : 1)),
+          (run.is_rtl ? CURSOR_FORWARD : CURSOR_BACKWARD));
     }
   }
   return EdgeSelectionModel(CURSOR_RIGHT);
 }
 
 std::vector<RenderText::FontSpan> RenderTextHarfBuzz::GetFontSpansForTesting() {
   NOTIMPLEMENTED();
   return std::vector<RenderText::FontSpan>();
 }
 
@@ skipping 13 matching lines @@
     SelectionModel edge = EdgeSelectionModel(direction);
     if (edge.caret_pos() == selection.caret_pos())
       return edge;
     int visual_index = (direction == CURSOR_RIGHT) ? 0 : runs_.size() - 1;
     run = runs_[visual_to_logical_[visual_index]];
   } else {
     // If the cursor is moving within the current run, just move it by one
     // grapheme in the appropriate direction.
     run = runs_[run_index];
     size_t caret = selection.caret_pos();
-    bool forward_motion =
-        (run->direction == UBIDI_RTL) == (direction == CURSOR_LEFT);
+    bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT);
     if (forward_motion) {
       if (caret < LayoutIndexToTextIndex(run->range.end())) {
         caret = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD);
         return SelectionModel(caret, CURSOR_BACKWARD);
       }
     } else {
       if (caret > LayoutIndexToTextIndex(run->range.start())) {
         caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD);
         return SelectionModel(caret, CURSOR_FORWARD);
       }
     }
     // The cursor is at the edge of a run; move to the visually adjacent run.
     int visual_index = logical_to_visual_[run_index];
     visual_index += (direction == CURSOR_LEFT) ? -1 : 1;
     if (visual_index < 0 || visual_index >= static_cast<int>(runs_.size()))
       return EdgeSelectionModel(direction);
     run = runs_[visual_to_logical_[visual_index]];
   }
-  bool forward_motion =
-      (run->direction == UBIDI_RTL) == (direction == CURSOR_LEFT);
+  bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT);
   return forward_motion ? FirstSelectionModelInsideRun(run) :
                           LastSelectionModelInsideRun(run);
 }
 
 SelectionModel RenderTextHarfBuzz::AdjacentWordSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
   // TODO(ckocagil): This implementation currently matches RenderTextWin, but it
   // should match the native behavior on other platforms.
   if (obscured())
@@ skipping 283 matching lines @@
 
 SelectionModel RenderTextHarfBuzz::LastSelectionModelInsideRun(
     const internal::TextRunHarfBuzz* run) {
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 void RenderTextHarfBuzz::ItemizeText() {
   const base::string16& text = GetLayoutText();
-  const bool is_rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
+  const bool is_text_rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
   DCHECK_NE(0U, text.length());
 
   // If ICU fails to itemize the text, we set |fake_runs| and create a run that
   // spans the entire text. This is needed because early returning and leaving
   // the runs set empty causes some clients to crash/misbehave since they expect
   // non-zero text metrics from a non-empty text.
-  bool fake_runs = false;
-  UErrorCode result = U_ZERO_ERROR;
-
-  UBiDi* line = ubidi_openSized(text.length(), 0, &result);
-  if (U_FAILURE(result)) {
-    NOTREACHED();
-    fake_runs = true;
-  } else {
-    ubidi_setPara(line, text.c_str(), text.length(),
-                  is_rtl ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR, NULL,
-                  &result);
-    if (U_FAILURE(result)) {
-      NOTREACHED();
-      fake_runs = true;
-    }
-  }
+  base::i18n::BiDiLineIterator bidi_iterator;
+  bool fake_runs = !bidi_iterator.Open(text, is_text_rtl, false);
 
   // Temporarily apply composition underlines and selection colors.
   ApplyCompositionAndSelectionStyles();
 
   // Build the list of runs from the script items and ranged styles. Use an
   // empty color BreakList to avoid breaking runs at color boundaries.
   BreakList<SkColor> empty_colors;
   empty_colors.SetMax(text.length());
   internal::StyleIterator style(empty_colors, styles());
 
   for (size_t run_break = 0; run_break < text.length();) {
     internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz;
     run->range.set_start(run_break);
     run->font_style = (style.style(BOLD) ? Font::BOLD : 0) |
                       (style.style(ITALIC) ? Font::ITALIC : 0);
     run->strike = style.style(STRIKE);
     run->diagonal_strike = style.style(DIAGONAL_STRIKE);
     run->underline = style.style(UNDERLINE);
 
     if (fake_runs) {
       run_break = text.length();
     } else {
       int32 script_item_break = 0;
-      ubidi_getLogicalRun(line, run_break, &script_item_break, &run->level);
+      bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level);
       // Find the length and script of this script run.
       script_item_break = ScriptInterval(text, run_break,
           script_item_break - run_break, &run->script) + run_break;
 
       // Find the next break and advance the iterators as needed.
       run_break = std::min(static_cast<size_t>(script_item_break),
                            TextIndexToLayoutIndex(style.GetRange().end()));
 
       // Break runs adjacent to character substrings in certain code blocks.
       // This avoids using their fallback fonts for more characters than needed,
@@ skipping 12 matching lines @@
             run_break = run_start + iter.array_pos();
             break;
           }
         }
       }
     }
 
     DCHECK(IsValidCodePointIndex(text, run_break));
     style.UpdatePosition(LayoutIndexToTextIndex(run_break));
     run->range.set_end(run_break);
-    const UChar* uchar_start = ubidi_getText(line);
-    // TODO(ckocagil): Add |ubidi_getBaseDirection| to i18n::BiDiLineIterator
-    // and remove the bare ICU use here.
-    run->direction = ubidi_getBaseDirection(uchar_start + run->range.start(),
-                                            run->range.length());
-    if (run->direction == UBIDI_NEUTRAL)
-      run->direction = is_rtl ? UBIDI_RTL : UBIDI_LTR;
+    UBiDiDirection direction = ubidi_getBaseDirection(
+        text.c_str() + run->range.start(), run->range.length());
+    if (direction == UBIDI_NEUTRAL)
+      run->is_rtl = is_text_rtl;
+    else
+      run->is_rtl = direction == UBIDI_RTL;
     runs_.push_back(run);
   }
 
-  ubidi_close(line);
-
   // Undo the temporarily applied composition underlines and selection colors.
   UndoCompositionAndSelectionStyles();
 
   const size_t num_runs = runs_.size();
   std::vector<UBiDiLevel> levels(num_runs);
   for (size_t i = 0; i < num_runs; ++i)
     levels[i] = runs_[i]->level;
   visual_to_logical_.resize(num_runs);
   ubidi_reorderVisual(&levels[0], num_runs, &visual_to_logical_[0]);
   logical_to_visual_.resize(num_runs);
@@ skipping 12 matching lines @@
                                                 run->font_size);
 
   // Create a HarfBuzz buffer and add the string to be shaped. The HarfBuzz
   // buffer holds our text, run information to be used by the shaping engine,
   // and the resulting glyph data.
   hb_buffer_t* buffer = hb_buffer_create();
   hb_buffer_add_utf16(buffer, reinterpret_cast<const uint16*>(text.c_str()),
                       text.length(), run->range.start(), run->range.length());
   hb_buffer_set_script(buffer, ICUScriptToHBScript(run->script));
   hb_buffer_set_direction(buffer,
-      run->direction == UBIDI_LTR ? HB_DIRECTION_LTR : HB_DIRECTION_RTL);
+      run->is_rtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
   // TODO(ckocagil): Should we determine the actual language?
   hb_buffer_set_language(buffer, hb_language_get_default());
 
   // Shape the text.
   hb_shape(harfbuzz_font, buffer, NULL, 0);
 
   // Populate the run fields with the resulting glyph data in the buffer.
   unsigned int glyph_count = 0;
   hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count);
   hb_glyph_position_t* hb_positions = hb_buffer_get_glyph_positions(buffer,
@@ skipping 12 matching lines @@
     run->positions[i].set(run->width + x_offset, y_offset);
     run->width +=
         SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_advance));
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
 }
 
 }  // namespace gfx