Reintroduce password support to NativeTextfieldViews

base/utf_offset_string_conversions.cc

-// 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.
 
 #include "base/utf_offset_string_conversions.h"
 
 #include <algorithm>
 
+#include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_piece.h"
+#include "base/third_party/icu/icu_utf.h"
 #include "base/utf_string_conversion_utils.h"
 
 using base::PrepareForUTF16Or32Output;
 using base::PrepareForUTF8Output;
 using base::ReadUnicodeCharacter;
 using base::WriteUnicodeCharacter;
 
+namespace {
+
 // Converts the given source Unicode character type to the given destination
 // Unicode character type as a STL string. The given input buffer and size
 // determine the source, and the given output STL string will be replaced by
 // the result.
 template<typename SrcChar, typename DestStdString>
 bool ConvertUnicode(const SrcChar* src,
                     size_t src_len,
                     DestStdString* output,
                     std::vector<size_t>* offsets_for_adjustment) {
   if (offsets_for_adjustment) {
@@ skipping 21 matching lines @@
       // character read, not after it (so that incrementing it in the loop
       // increment will place it at the right location), so we need to account
       // for that in determining the amount that was read.
       offset_adjuster.Add(OffsetAdjuster::Adjustment(original_i,
           i - original_i + 1, chars_written));
     }
   }
   return success;
 }
 
+}  // namespace
+
+bool IsValidCodePointIndex(const string16& s, size_t index) {
+  return index == 0 || index == s.length() ||
+    !(CBU16_IS_TRAIL(s[index]) && CBU16_IS_LEAD(s[index - 1]));
+}
+
+ptrdiff_t Utf16IndexToOffset(const string16& s, size_t base, size_t pos) {
+  DCHECK_LE(base, s.length());
+  DCHECK_LE(pos, s.length());
+  ptrdiff_t delta = 0;
+  while (base < pos)
+    delta += IsValidCodePointIndex(s, base++) ? 1 : 0;
+  while (pos < base)
+    delta -= IsValidCodePointIndex(s, pos++) ? 1 : 0;
+  return delta;
+}
+
+size_t Utf16OffsetToIndex(const string16& s, size_t pos, ptrdiff_t offset) {
+  DCHECK_LE(pos, s.length());
+  while (offset > 0 && pos < s.length())
+    offset -= IsValidCodePointIndex(s, pos++) ? 1 : 0;
+  while (offset < 0 && pos > 0)
+    offset += IsValidCodePointIndex(s, --pos) ? 1 : 0;
+  // If offset != 0 then we ran off the edge of the string, which shouldn't
+  // happen but is handled anyway for safety.
+  DCHECK_EQ(offset, 0);
+  // Since the second half of a surrogate pair has "length" zero, there is an
+  // ambiguity in the returned position. Resolve it by always returning a valid
+  // index.
+  if (!IsValidCodePointIndex(s, pos))

[xji, 2012/03/01 19:33:49]

this line only reachable when |offset| == 0 at entry point, right? (assume line
89 holds true).

[benrg, 2012/03/01 21:07:52]

No, it's also reachable when offset > 0 and the desired end point happens to be
right after a surrogate pair. The loop exits after stepping over the first half
of the surrogate.

+    ++pos;
+  return pos;
+}
+
 bool UTF8ToUTF16AndAdjustOffset(const char* src,
                                 size_t src_len,
                                 string16* output,
                                 size_t* offset_for_adjustment) {
   std::vector<size_t> offsets;
   if (offset_for_adjustment)
     offsets.push_back(*offset_for_adjustment);
   PrepareForUTF16Or32Output(src, src_len, output);
   bool ret = ConvertUnicode(src, src_len, output, &offsets);
   if (offset_for_adjustment)
@@ skipping 89 matching lines @@
     if (*offset <= i->original_offset)
       break;
     if (*offset < (i->original_offset + i->original_length)) {
       *offset = string16::npos;
       return;
     }
     adjustment += (i->original_length - i->output_length);
   }
   *offset -= adjustment;
 }