Reintroduce password support to NativeTextfieldViews

base/utf_offset_string_conversions.h

-// 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.
 
 #ifndef BASE_UTF_OFFSET_STRING_CONVERSIONS_H_
 #define BASE_UTF_OFFSET_STRING_CONVERSIONS_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #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

[msw, 2012/03/01 22:48:54]

Maybe use Basic Multilingual Plane for the laymen (like me)?

[benrg, 2012/03/02 00:06:08]

Rewritten.

+// 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,
+                                         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.
 // If this isn't possible because an offset points past the end of the source
 // strings or into the middle of a multibyte sequence, the offending offset will
 // be set to string16::npos. |offset[s]_for_adjustment| may be NULL.
 BASE_EXPORT bool UTF8ToUTF16AndAdjustOffset(const char* src,
                                             size_t src_len,
                                             string16* output,
                                             size_t* offset_for_adjustment);
@@ skipping 55 matching lines @@
   void Add(const Adjustment& adjustment);
 
  private:
   void AdjustOffset(std::vector<size_t>::iterator offset);
 
   std::vector<size_t>* offsets_for_adjustment_;
   std::vector<Adjustment> adjustments_;
 };
 
 #endif  // BASE_UTF_OFFSET_STRING_CONVERSIONS_H_