Reintroduce password support to NativeTextfieldViews

base/utf_offset_string_conversions.h

Index: base/utf_offset_string_conversions.h
diff --git a/base/utf_offset_string_conversions.h b/base/utf_offset_string_conversions.h
index 97b641edda8b49a9a9797ec4cd08966f2400c277..a63d6a46d02e761f3c99cbe67c0cc087bb65e14c 100644
--- a/base/utf_offset_string_conversions.h
+++ b/base/utf_offset_string_conversions.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -13,6 +13,36 @@
 #include "base/string16.h"
 #include "base/string_piece.h"
 
+// Returns false if s[index-1] is a high surrogate and s[index] is a low
+// surrogate, true otherwise.
+BASE_EXPORT bool IsValidCodePointIndex(const string16& s, size_t index);
+
+// |Utf16IndexToOffset| returns the number of code points between |base| and
+// |pos| in the given string. |Utf16OffsetToIndex| returns the index that is
+// |offset| code points away from the given |base| index. These functions are
+// named after glib's |g_utf8_pointer_to_offset| and |g_utf8_offset_to_pointer|,
+// which perform the same function for UTF-8.
+// Unpaired surrogates in the string are counted as BMP characters. If an
+// argument index points to the middle of a surrogate pair, it is treated as
+// though it pointed to the end of that pair (in other words, the first word of
+// any surrogate pair is the one that is counted). The index returned by
+// |Utf16OffsetToIndex| never points to the middle of a surrogate pair.
+// The following identities hold:
+//   If |s| contains no surrogate pairs, then
+//     Utf16IndexToOffset(s, base, pos) == pos - base
+//     Utf16OffsetToIndex(s, base, offset) == base + offset
+//   If |pos| does not point to the middle of a surrogate pair, then
+//     Utf16OffsetToIndex(s, base, Utf16IndexToOffset(s, base, pos)) == pos
+//   Always,
+//     Utf16IndexToOffset(s, base, Utf16OffsetToIndex(s, base, ofs)) == ofs
+//     Utf16IndexToOffset(s, i, j) == -Utf16IndexToOffset(s, j, i)
+BASE_EXPORT ptrdiff_t Utf16IndexToOffset(const string16& s,

[xji, 2012/02/25 00:06:14]

since those functions only used in RenderTextLinux (at least for now), and you
are no longer doing optimization (cache the last_text_index_ and
last_layout_pointer_), the |base| is always 0 for the callers. Then, it would be
better to remove |base| to
make the function simpler and without the problems Mike concerned.

It is similar as avoiding the (naming) confusion by declare
Utf16IndexToOffset(const string16* s, size_t pos)
and change the caller from
Utf16IndexToOffset(s, base, pos)
to
Utf16IndexToOffset(&s+base, pos-base)
Similar for Utf16OffstToIndex.

[benrg, 2012/03/01 17:18:00]

The problem is that restricting these functions to anchor at the start of the
string makes them almost useless because any interesting algorithms based on
them will become O(n^2). The RenderText code is already O(n^2) in a bunch of
places and the (now) lack of optimization in this CL is justified only because
it doesn't make things worse.
I assume you mean char16* rather than string16*. That would work for
Utf16IndexToOffset, but Utf16OffsetToIndex(char16*, ptrdiff_t) is not possible
because there's the danger of walking off the beginning or end of the string
when there are unpaired surrogates. This would all be much simpler if we didn't
have to worry about unpaired surrogates. Perhaps we don't. RenderText::SetText
could map them to U+FFFD. But that might break something that relies on
RenderText not munging the text.

+                                         size_t base,
+                                         size_t pos);
+BASE_EXPORT size_t Utf16OffsetToIndex(const string16& s,
+                                      size_t base,
+                                      ptrdiff_t offset);
+
 // Like the conversions in utf_string_conversions.h, but also takes one or more
 // offsets (|offset[s]_for_adjustment|) into the source strings, each offset
 // will be adjusted to point at the same logical place in the result strings.