base: Convert scoped_arrays to the new scoped_ptr style.

base/i18n/icu_string_conversions.cc

 // 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/i18n/icu_string_conversions.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 170 matching lines @@
   // output would be at most the same as the number of bytes in input. There
   // is no single-byte encoding in which a character is mapped to a
   // non-BMP character requiring two 2-byte units.
   //
   // Moreover, non-BMP characters in legacy multibyte encodings
   // (e.g. EUC-JP, GB18030) take at least 2 bytes. The only exceptions are
   // BOCU and SCSU, but we don't care about them.
   size_t uchar_max_length = encoded.length() + 1;
 
   SetUpErrorHandlerForToUChars(on_error, converter, &status);
-  scoped_array<char16> buffer(new char16[uchar_max_length]);
+  scoped_ptr<char16[]> buffer(new char16[uchar_max_length]);
   int actual_size = ucnv_toUChars(converter, buffer.get(),
       static_cast<int>(uchar_max_length), encoded.data(),
       static_cast<int>(encoded.length()), &status);
   ucnv_close(converter);
   if (!U_SUCCESS(status)) {
     utf16->clear();  // Make sure the output is empty on error.
     return false;
   }
 
   utf16->assign(buffer.get(), actual_size);
@@ skipping 44 matching lines @@
   if (!U_SUCCESS(status))
     return false;
 
   // The maximum length in 4 byte unit of UTF-32 output would be
   // at most the same as the number of bytes in input. In the worst
   // case of GB18030 (excluding escaped-based encodings like ISO-2022-JP),
   // this can be 4 times larger than actually needed.
   size_t wchar_max_length = encoded.length() + 1;
 
   SetUpErrorHandlerForToUChars(on_error, converter, &status);
-  scoped_array<wchar_t> buffer(new wchar_t[wchar_max_length]);
+  scoped_ptr<wchar_t[]> buffer(new wchar_t[wchar_max_length]);
   int actual_size = ucnv_toAlgorithmic(utf32_platform_endian(), converter,
       reinterpret_cast<char*>(buffer.get()),
       static_cast<int>(wchar_max_length) * sizeof(wchar_t), encoded.data(),
       static_cast<int>(encoded.length()), &status);
   ucnv_close(converter);
   if (!U_SUCCESS(status)) {
     wide->clear();  // Make sure the output is empty on error.
     return false;
   }
 
   // actual_size is # of bytes.
   wide->assign(buffer.get(), actual_size / sizeof(wchar_t));
   return true;
 #endif  // defined(WCHAR_T_IS_UTF32)
 }
 
 bool ConvertToUtf8AndNormalize(const std::string& text,
                                const std::string& charset,
                                std::string* result) {
   result->clear();
   string16 utf16;
   if (!CodepageToUTF16(
       text, charset.c_str(), OnStringConversionError::FAIL, &utf16))
     return false;
 
   UErrorCode status = U_ZERO_ERROR;
   size_t max_length = utf16.length() + 1;
   string16 normalized_utf16;
-  scoped_array<char16> buffer(new char16[max_length]);
+  scoped_ptr<char16[]> buffer(new char16[max_length]);
   int actual_length = unorm_normalize(
       utf16.c_str(), utf16.length(), UNORM_NFC, 0,
       buffer.get(), static_cast<int>(max_length), &status);
   if (!U_SUCCESS(status))
     return false;
   normalized_utf16.assign(buffer.get(), actual_length);
 
   return UTF16ToUTF8(normalized_utf16.data(),
                      normalized_utf16.length(), result);
 }
 
 }  // namespace base