Replace SmartArrayPointer<T> with unique_ptr<T[]>

src/runtime/runtime-i18n.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #ifdef V8_I18N_SUPPORT
 #include "src/runtime/runtime-utils.h"
 
+#include <memory>
+
 #include "src/api.h"
 #include "src/api-natives.h"
 #include "src/arguments.h"
 #include "src/factory.h"
 #include "src/i18n.h"
 #include "src/isolate-inl.h"
 #include "src/messages.h"
 
 #include "unicode/brkiter.h"
 #include "unicode/calendar.h"
@@ skipping 19 matching lines @@
 #include "unicode/unistr.h"
 #include "unicode/unum.h"
 #include "unicode/uversion.h"
 
 
 namespace v8 {
 namespace internal {
 namespace {
 
 const UChar* GetUCharBufferFromFlat(const String::FlatContent& flat,
-                                    base::SmartArrayPointer<uc16>* dest,
+                                    std::unique_ptr<uc16[]>* dest,
                                     int32_t length) {
   DCHECK(flat.IsFlat());
   if (flat.IsOneByte()) {
-    if (dest->is_empty()) {
-      dest->Reset(NewArray<uc16>(length));
+    if (!*dest) {
+      dest->reset(NewArray<uc16>(length));
       CopyChars(dest->get(), flat.ToOneByteVector().start(), length);
     }
     return reinterpret_cast<const UChar*>(dest->get());
   } else {
     return reinterpret_cast<const UChar*>(flat.ToUC16Vector().start());
   }
 }
 
 }  // namespace
 
@@ skipping 503 matching lines @@
   icu::Collator* collator = Collator::UnpackCollator(isolate, collator_holder);
   if (!collator) return isolate->ThrowIllegalOperation();
 
   string1 = String::Flatten(string1);
   string2 = String::Flatten(string2);
   DisallowHeapAllocation no_gc;
   int32_t length1 = string1->length();
   int32_t length2 = string2->length();
   String::FlatContent flat1 = string1->GetFlatContent();
   String::FlatContent flat2 = string2->GetFlatContent();
-  base::SmartArrayPointer<uc16> sap1;
-  base::SmartArrayPointer<uc16> sap2;
+  std::unique_ptr<uc16[]> sap1;
+  std::unique_ptr<uc16[]> sap2;
   const UChar* string_val1 = GetUCharBufferFromFlat(flat1, &sap1, length1);
   const UChar* string_val2 = GetUCharBufferFromFlat(flat2, &sap2, length2);
   UErrorCode status = U_ZERO_ERROR;
   UCollationResult result =
       collator->compare(string_val1, length1, string_val2, length2, status);
   if (U_FAILURE(status)) return isolate->ThrowIllegalOperation();
 
   return *isolate->factory()->NewNumberFromInt(result);
 }
 
@@ skipping 13 matching lines @@
   DCHECK(args.length() == 2);
 
   CONVERT_ARG_HANDLE_CHECKED(String, s, 0);
   CONVERT_NUMBER_CHECKED(int, form_id, Int32, args[1]);
   CHECK(form_id >= 0 &&
         static_cast<size_t>(form_id) < arraysize(normalizationForms));
 
   int length = s->length();
   s = String::Flatten(s);
   icu::UnicodeString result;
-  base::SmartArrayPointer<uc16> sap;
+  std::unique_ptr<uc16[]> sap;
   UErrorCode status = U_ZERO_ERROR;
   {
     DisallowHeapAllocation no_gc;
     String::FlatContent flat = s->GetFlatContent();
     const UChar* src = GetUCharBufferFromFlat(flat, &sap, length);
     icu::UnicodeString input(false, src, length);
     // Getting a singleton. Should not free it.
     const icu::Normalizer2* normalizer =
         icu::Normalizer2::getInstance(nullptr, normalizationForms[form_id].name,
                                       normalizationForms[form_id].mode, status);
@@ skipping 78 matching lines @@
   if (!break_iterator) return isolate->ThrowIllegalOperation();
 
   icu::UnicodeString* u_text = reinterpret_cast<icu::UnicodeString*>(
       break_iterator_holder->GetInternalField(1));
   delete u_text;
 
   int length = text->length();
   text = String::Flatten(text);
   DisallowHeapAllocation no_gc;
   String::FlatContent flat = text->GetFlatContent();
-  base::SmartArrayPointer<uc16> sap;
+  std::unique_ptr<uc16[]> sap;
   const UChar* text_value = GetUCharBufferFromFlat(flat, &sap, length);
   u_text = new icu::UnicodeString(text_value, length);
   break_iterator_holder->SetInternalField(1, reinterpret_cast<Smi*>(u_text));
 
   break_iterator->setText(*u_text);
 
   return isolate->heap()->undefined_value();
 }
 
 
@@ skipping 91 matching lines @@
 
   // Greek uppercasing has to be done via transliteration.
   // TODO(jshin): Drop this special-casing once ICU's regular case conversion
   // API supports Greek uppercasing. See
   // http://bugs.icu-project.org/trac/ticket/10582 .
   // In the meantime, if there's no Greek character in |s|, call this
   // function again with the root locale (lang="").
   // ICU's C API for transliteration is nasty and we just use C++ API.
   if (V8_UNLIKELY(is_to_upper && lang[0] == 'e' && lang[1] == 'l')) {
     icu::UnicodeString converted;
-    base::SmartArrayPointer<uc16> sap;
+    std::unique_ptr<uc16[]> sap;
     {
       DisallowHeapAllocation no_gc;
       String::FlatContent flat = s->GetFlatContent();
       const UChar* src = GetUCharBufferFromFlat(flat, &sap, src_length);
       // Starts with the source string (read-only alias with copy-on-write
       // semantics) and will be modified to contain the converted result.
       // Using read-only alias at first saves one copy operation if
       // transliteration does not change the input, which is rather rare.
       // Moreover, transliteration takes rather long so that saving one copy
       // helps only a little bit.
       converted.setTo(false, src, src_length);
       ConvertCaseWithTransliterator(&converted, "el-Upper");
       // If no change is made, just return |s|.
       if (converted.getBuffer() == src) return *s;
     }
     RETURN_RESULT_OR_FAILURE(
         isolate,
         isolate->factory()->NewStringFromTwoByte(Vector<const uint16_t>(
             reinterpret_cast<const uint16_t*>(converted.getBuffer()),
             converted.length())));
   }
 
   auto case_converter = is_to_upper ? u_strToUpper : u_strToLower;
 
   int32_t dest_length = src_length;
   UErrorCode status;
   Handle<SeqTwoByteString> result;
-  base::SmartArrayPointer<uc16> sap;
+  std::unique_ptr<uc16[]> sap;
 
   // This is not a real loop. It'll be executed only once (no overflow) or
   // twice (overflow).
   for (int i = 0; i < 2; ++i) {
     result =
         isolate->factory()->NewRawTwoByteString(dest_length).ToHandleChecked();
     DisallowHeapAllocation no_gc;
     String::FlatContent flat = s->GetFlatContent();
     const UChar* src = GetUCharBufferFromFlat(flat, &sap, src_length);
     status = U_ZERO_ERROR;
@@ skipping 283 matching lines @@
   Handle<FixedArray> date_cache_version =
       Handle<FixedArray>::cast(isolate->eternal_handles()->GetSingleton(
           EternalHandles::DATE_CACHE_VERSION));
   return date_cache_version->get(0);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_I18N_SUPPORT