Add UTF16ToUTF8AndAdjustOffset() to base/.

base/utf_offset_string_conversions.cc

 // Copyright (c) 2011 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/memory/scoped_ptr.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversion_utils.h"
 
 using base::PrepareForUTF16Or32Output;
+using base::PrepareForUTF8Output;
 using base::ReadUnicodeCharacter;
 using base::WriteUnicodeCharacter;
 
 // 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.
-bool ConvertUnicode(const char* src,
+template<typename SrcChar, typename DestStdString>
+bool ConvertUnicode(const SrcChar* src,
                     size_t src_len,
-                    string16* output,
+                    DestStdString* output,
                     std::vector<size_t>* offsets_for_adjustment) {
   if (offsets_for_adjustment) {
     std::for_each(offsets_for_adjustment->begin(),
                   offsets_for_adjustment->end(),
-                  LimitOffset<string16>(src_len));
+                  LimitOffset<DestStdString>(src_len));
   }
 
   // ICU requires 32-bit numbers.
   bool success = true;
   OffsetAdjuster offset_adjuster(offsets_for_adjustment);
   int32 src_len32 = static_cast<int32>(src_len);
   for (int32 i = 0; i < src_len32; i++) {
     uint32 code_point;
     size_t original_i = i;
     size_t chars_written = 0;
@@ skipping 52 matching lines @@
 
 string16 UTF8ToUTF16AndAdjustOffsets(
     const base::StringPiece& utf8,
     std::vector<size_t>* offsets_for_adjustment) {
   string16 result;
   UTF8ToUTF16AndAdjustOffsets(utf8.data(), utf8.length(), &result,
                               offsets_for_adjustment);
   return result;
 }
 
+bool UTF16ToUTF8AndAdjustOffset(const char16* src,
+                                size_t src_len,
+                                std::string* output,
+                                size_t* offset_for_adjustment) {
+  std::vector<size_t> offsets;
+  if (offset_for_adjustment)
+    offsets.push_back(*offset_for_adjustment);
+  bool ret = UTF16ToUTF8AndAdjustOffsets(src, src_len, output, &offsets);
+  if (offset_for_adjustment)
+    *offset_for_adjustment = offsets[0];
+  return ret;
+}
+
+bool UTF16ToUTF8AndAdjustOffsets(const char16* src,
+                                 size_t src_len,
+                                 std::string* output,
+                                 std::vector<size_t>* offsets_for_adjustment) {
+  PrepareForUTF8Output(src, src_len, output);
+  return ConvertUnicode(src, src_len, output, offsets_for_adjustment);
+}
+
+std::string UTF16ToUTF8AndAdjustOffset(
+    const base::StringPiece16& utf16,
+    size_t* offset_for_adjustment) {
+  std::vector<size_t> offsets;
+  if (offset_for_adjustment)
+    offsets.push_back(*offset_for_adjustment);
+  std::string result;
+  UTF16ToUTF8AndAdjustOffsets(utf16.data(), utf16.length(), &result,
+                              &offsets);
+  if (offset_for_adjustment)
+    *offset_for_adjustment = offsets[0];
+  return result;
+}
+
+std::string UTF16ToUTF8AndAdjustOffsets(
+    const base::StringPiece16& utf16,
+    std::vector<size_t>* offsets_for_adjustment) {
+  std::string result;
+  UTF16ToUTF8AndAdjustOffsets(utf16.data(), utf16.length(), &result,
+                              offsets_for_adjustment);
+  return result;
+}
+
+
 OffsetAdjuster::Adjustment::Adjustment(size_t original_offset,
                                        size_t original_length,
                                        size_t output_length)
     : original_offset(original_offset),
       original_length(original_length),
       output_length(output_length) {
 }
 
 OffsetAdjuster::OffsetAdjuster(std::vector<size_t>* offsets_for_adjustment)
     : offsets_for_adjustment_(offsets_for_adjustment) {
@@ skipping 24 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;
 }