Clean up recent string conversion function changes, part 1: Remove unnecessar...

base/utf_string_conversions.cc

 // Copyright (c) 2009 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_string_conversions.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 203 matching lines @@
     // Otherwise assume that the UTF-8 sequences will have 2 bytes for each
     // character.
     output->reserve(src_len / 2);
   }
 }
 
 }  // namespace
 
 // UTF-8 <-> Wide --------------------------------------------------------------
 
-bool WideToUTF8AndAdjustOffset(const wchar_t* src,
-                               size_t src_len,
-                               std::string* output,
-                               size_t* offset_for_adjustment) {
+bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output) {
   PrepareForUTF8Output(src, src_len, output);
-  return ConvertUnicode<wchar_t, std::string>(src, src_len, output,
-                                              offset_for_adjustment);
+  return ConvertUnicode<wchar_t, std::string>(src, src_len, output, NULL);
 }
 
-std::string WideToUTF8AndAdjustOffset(const std::wstring& wide,
-                                      size_t* offset_for_adjustment) {
+std::string WideToUTF8(const std::wstring& wide) {
   std::string ret;
   // Ignore the success flag of this call, it will do the best it can for
   // invalid input, which is what we want here.
-  WideToUTF8AndAdjustOffset(wide.data(), wide.length(), &ret,
-                            offset_for_adjustment);
+  WideToUTF8(wide.data(), wide.length(), &ret);
   return ret;
 }
 
 bool UTF8ToWideAndAdjustOffset(const char* src,
                                size_t src_len,
                                std::wstring* output,
                                size_t* offset_for_adjustment) {
   PrepareForUTF16Or32Output(src, src_len, output);
   return ConvertUnicode<char, std::wstring>(src, src_len, output,
                                             offset_for_adjustment);
 }
 
 std::wstring UTF8ToWideAndAdjustOffset(const base::StringPiece& utf8,
                                        size_t* offset_for_adjustment) {
   std::wstring ret;
   UTF8ToWideAndAdjustOffset(utf8.data(), utf8.length(), &ret,
                             offset_for_adjustment);
   return ret;
 }
 
 // UTF-16 <-> Wide -------------------------------------------------------------
 
 #if defined(WCHAR_T_IS_UTF16)
 
 // When wide == UTF-16, then conversions are a NOP.
-bool WideToUTF16AndAdjustOffset(const wchar_t* src,
-                                size_t src_len,
-                                string16* output,
-                                size_t* offset_for_adjustment) {
+bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output) {
   output->assign(src, src_len);
-  if (offset_for_adjustment && (*offset_for_adjustment >= src_len))
-    *offset_for_adjustment = string16::npos;
   return true;
 }
 
-string16 WideToUTF16AndAdjustOffset(const std::wstring& wide,
-                                    size_t* offset_for_adjustment) {
-  if (offset_for_adjustment && (*offset_for_adjustment >= wide.length()))
-    *offset_for_adjustment = string16::npos;
+string16 WideToUTF16(const std::wstring& wide) {
   return wide;
 }
 
 bool UTF16ToWideAndAdjustOffset(const char16* src,
                                 size_t src_len,
                                 std::wstring* output,
                                 size_t* offset_for_adjustment) {
   output->assign(src, src_len);
   if (offset_for_adjustment && (*offset_for_adjustment >= src_len))
     *offset_for_adjustment = std::wstring::npos;
   return true;
 }
 
 std::wstring UTF16ToWideAndAdjustOffset(const string16& utf16,
                                         size_t* offset_for_adjustment) {
   if (offset_for_adjustment && (*offset_for_adjustment >= utf16.length()))
     *offset_for_adjustment = std::wstring::npos;
   return utf16;
 }
 
 #elif defined(WCHAR_T_IS_UTF32)
 
-bool WideToUTF16AndAdjustOffset(const wchar_t* src,
-                                size_t src_len,
-                                string16* output,
-                                size_t* offset_for_adjustment) {
+bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output) {
   output->clear();
   // Assume that normally we won't have any non-BMP characters so the counts
   // will be the same.
   output->reserve(src_len);
-  return ConvertUnicode<wchar_t, string16>(src, src_len, output,
-                                           offset_for_adjustment);
+  return ConvertUnicode<wchar_t, string16>(src, src_len, output, NULL);
 }
 
-string16 WideToUTF16AndAdjustOffset(const std::wstring& wide,
-                                    size_t* offset_for_adjustment) {
+string16 WideToUTF16(const std::wstring& wide) {
   string16 ret;
-  WideToUTF16AndAdjustOffset(wide.data(), wide.length(), &ret,
-                             offset_for_adjustment);
+  WideToUTF16(wide.data(), wide.length(), &ret);
   return ret;
 }
 
 bool UTF16ToWideAndAdjustOffset(const char16* src,
                                 size_t src_len,
                                 std::wstring* output,
                                 size_t* offset_for_adjustment) {
   output->clear();
   // Assume that normally we won't have any non-BMP characters so the counts
   // will be the same.
@@ skipping 55 matching lines @@
 
 bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output) {
   return WideToUTF8(src, src_len, output);
 }
 
 std::string UTF16ToUTF8(const string16& utf16) {
   return WideToUTF8(utf16);
 }
 
 #endif