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 "third_party/skia/include/core/SkTypeface.h"
+#include "ui/base/text/utf16_indexing.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 76 matching lines @@
   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_;
   }
 
   return SelectionModel(
-      Utf8IndexToUtf16Index(selection_end),
-      Utf8IndexToUtf16Index(caret_pos),
+      LayoutIndexToTextIndex(selection_end),
+      LayoutIndexToTextIndex(caret_pos),
       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) {
       size_t cursor = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD);
@@ skipping 14 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 = LayoutIndexToTextIndex(LayoutIndexOfAdjacentGrapheme(
+            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 16 matching lines @@
     return GetSelectionBounds();
   else
     return CalculateSubstringBounds(from, to);
 }
 
 bool RenderTextLinux::IsCursorablePosition(size_t position) {
   if (position == 0 && text().empty())
     return true;
 
   EnsureLayout();
-  return (position < static_cast<size_t>(num_log_attrs_) &&
-          log_attrs_[position].is_cursor_position);
+  ptrdiff_t offset = ui::UTF16IndexToOffset(text(), 0, position);
+  return (offset < num_log_attrs_ && log_attrs_[offset].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);
+
+    // These are used by SetupPangoAttributes.
+    layout_text_ = pango_layout_get_text(layout_);
+    layout_text_len_ = strlen(layout_text_);
+
     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_);
   }
 }
 
 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());
+    size_t end_index = TextIndexToLayoutIndex(styles[i].range.end());
     style_ranges_utf8.push_back(ui::Range(start_index, end_index));
     start_index = end_index;
   }
 
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
   renderer.SetFontSmoothingSettings(true, !background_is_transparent());
 
   for (GSList* it = current_line_->runs; it; it = it->next) {
     PangoLayoutRun* run = reinterpret_cast<PangoLayoutRun*>(it->data);
@@ skipping 74 matching lines @@
     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));
+  return LayoutIndexToTextIndex(
+      LayoutIndexOfAdjacentGrapheme(TextIndexToLayoutIndex(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);
+    size_t run_start = LayoutIndexToTextIndex(item->offset);
+    size_t run_end = LayoutIndexToTextIndex(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,
+size_t RenderTextLinux::LayoutIndexOfAdjacentGrapheme(
+    size_t layout_index_of_current_grapheme,
     LogicalCursorDirection direction) const {
-  const char* ch = layout_text_ + utf8_index_of_current_grapheme;
+  const char* ch = layout_text_ + layout_index_of_current_grapheme;
   int char_offset = static_cast<int>(g_utf8_pointer_to_offset(layout_text_,
                                                               ch));
   int start_char_offset = char_offset;
   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);
     }
   }
 
   ch = g_utf8_offset_to_pointer(ch, char_offset - start_char_offset);
   return static_cast<size_t>(ch - layout_text_);
 }
 
 SelectionModel RenderTextLinux::FirstSelectionModelInsideRun(
     const PangoItem* item) const {
-  size_t caret = Utf8IndexToUtf16Index(item->offset);
-  size_t cursor = Utf8IndexToUtf16Index(
-      Utf8IndexOfAdjacentGrapheme(item->offset, CURSOR_FORWARD));
+  size_t caret = LayoutIndexToTextIndex(item->offset);
+  size_t cursor = LayoutIndexToTextIndex(
+      LayoutIndexOfAdjacentGrapheme(item->offset, CURSOR_FORWARD));
   return SelectionModel(cursor, caret, SelectionModel::TRAILING);
 }
 
 SelectionModel RenderTextLinux::LastSelectionModelInsideRun(
     const PangoItem* item) const {
-  size_t caret = Utf8IndexToUtf16Index(Utf8IndexOfAdjacentGrapheme(
+  size_t caret = LayoutIndexToTextIndex(LayoutIndexOfAdjacentGrapheme(
       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;
 }
 
-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 = ui::UTF16IndexToOffset(text(), 0, text_index);
+  const char* layout_pointer = g_utf8_offset_to_pointer(layout_text_, offset);
+  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;
+  long offset = g_utf8_pointer_to_offset(layout_text_, layout_pointer);
+  return ui::UTF16OffsetToIndex(text(), 0, offset);
 }
 
 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