Remove PropertyAttributes from SetProperty

src/i18n.cc

 // Copyright 2013 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.
 // limitations under the License.
 
 #include "src/i18n.h"
 
 #include "unicode/brkiter.h"
 #include "unicode/calendar.h"
 #include "unicode/coll.h"
@@ skipping 119 matching lines @@
   UErrorCode status = U_ZERO_ERROR;
   icu::UnicodeString pattern;
   date_format->toPattern(pattern);
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("pattern"),
       factory->NewStringFromTwoByte(
         Vector<const uint16_t>(
             reinterpret_cast<const uint16_t*>(pattern.getBuffer()),
             pattern.length())).ToHandleChecked(),
-      NONE,
       SLOPPY).Assert();
 
   // Set time zone and calendar.
   const icu::Calendar* calendar = date_format->getCalendar();
   const char* calendar_name = calendar->getType();
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("calendar"),
       factory->NewStringFromAsciiChecked(calendar_name),
-      NONE,
       SLOPPY).Assert();
 
   const icu::TimeZone& tz = calendar->getTimeZone();
   icu::UnicodeString time_zone;
   tz.getID(time_zone);
 
   icu::UnicodeString canonical_time_zone;
   icu::TimeZone::getCanonicalID(time_zone, canonical_time_zone, status);
   if (U_SUCCESS(status)) {
     if (canonical_time_zone == UNICODE_STRING_SIMPLE("Etc/GMT")) {
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("timeZone"),
           factory->NewStringFromStaticAscii("UTC"),
-          NONE,
           SLOPPY).Assert();
     } else {
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("timeZone"),
           factory->NewStringFromTwoByte(
             Vector<const uint16_t>(
                 reinterpret_cast<const uint16_t*>(
                     canonical_time_zone.getBuffer()),
                 canonical_time_zone.length())).ToHandleChecked(),
-          NONE,
           SLOPPY).Assert();
     }
   }
 
   // Ugly hack. ICU doesn't expose numbering system in any way, so we have
   // to assume that for given locale NumberingSystem constructor produces the
   // same digits as NumberFormat/Calendar would.
   status = U_ZERO_ERROR;
   icu::NumberingSystem* numbering_system =
       icu::NumberingSystem::createInstance(icu_locale, status);
   if (U_SUCCESS(status)) {
     const char* ns = numbering_system->getName();
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("numberingSystem"),
         factory->NewStringFromAsciiChecked(ns),
-        NONE,
         SLOPPY).Assert();
   } else {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("numberingSystem"),
         factory->undefined_value(),
-        NONE,
         SLOPPY).Assert();
   }
   delete numbering_system;
 
   // Set the locale
   char result[ULOC_FULLNAME_CAPACITY];
   status = U_ZERO_ERROR;
   uloc_toLanguageTag(
       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
   if (U_SUCCESS(status)) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromAsciiChecked(result),
-        NONE,
         SLOPPY).Assert();
   } else {
     // This would never happen, since we got the locale from ICU.
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromStaticAscii("und"),
-        NONE,
         SLOPPY).Assert();
   }
 }
 
 
 template<int internal_fields, EternalHandles::SingletonHandle field>
 Handle<ObjectTemplateInfo> GetEternal(Isolate* isolate) {
   if (isolate->eternal_handles()->Exists(field)) {
     return Handle<ObjectTemplateInfo>::cast(
         isolate->eternal_handles()->GetSingleton(field));
@@ skipping 123 matching lines @@
   Factory* factory = isolate->factory();
   icu::UnicodeString pattern;
   number_format->toPattern(pattern);
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("pattern"),
       factory->NewStringFromTwoByte(
         Vector<const uint16_t>(
             reinterpret_cast<const uint16_t*>(pattern.getBuffer()),
             pattern.length())).ToHandleChecked(),
-      NONE,
       SLOPPY).Assert();
 
   // Set resolved currency code in options.currency if not empty.
   icu::UnicodeString currency(number_format->getCurrency());
   if (!currency.isEmpty()) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("currency"),
         factory->NewStringFromTwoByte(
           Vector<const uint16_t>(
               reinterpret_cast<const uint16_t*>(currency.getBuffer()),
               currency.length())).ToHandleChecked(),
-        NONE,
         SLOPPY).Assert();
   }
 
   // Ugly hack. ICU doesn't expose numbering system in any way, so we have
   // to assume that for given locale NumberingSystem constructor produces the
   // same digits as NumberFormat/Calendar would.
   UErrorCode status = U_ZERO_ERROR;
   icu::NumberingSystem* numbering_system =
       icu::NumberingSystem::createInstance(icu_locale, status);
   if (U_SUCCESS(status)) {
     const char* ns = numbering_system->getName();
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("numberingSystem"),
         factory->NewStringFromAsciiChecked(ns),
-        NONE,
         SLOPPY).Assert();
   } else {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("numberingSystem"),
         factory->undefined_value(),
-        NONE,
         SLOPPY).Assert();
   }
   delete numbering_system;
 
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("useGrouping"),
       factory->ToBoolean(number_format->isGroupingUsed()),
-      NONE,
       SLOPPY).Assert();
 
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("minimumIntegerDigits"),
       factory->NewNumberFromInt(number_format->getMinimumIntegerDigits()),
-      NONE,
       SLOPPY).Assert();
 
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("minimumFractionDigits"),
       factory->NewNumberFromInt(number_format->getMinimumFractionDigits()),
-      NONE,
       SLOPPY).Assert();
 
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("maximumFractionDigits"),
       factory->NewNumberFromInt(number_format->getMaximumFractionDigits()),
-      NONE,
       SLOPPY).Assert();
 
   Handle<String> key =
       factory->NewStringFromStaticAscii("minimumSignificantDigits");
   if (JSReceiver::HasOwnProperty(resolved, key)) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("minimumSignificantDigits"),
         factory->NewNumberFromInt(number_format->getMinimumSignificantDigits()),
-        NONE,
         SLOPPY).Assert();
   }
 
   key = factory->NewStringFromStaticAscii("maximumSignificantDigits");
   if (JSReceiver::HasOwnProperty(resolved, key)) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("maximumSignificantDigits"),
         factory->NewNumberFromInt(number_format->getMaximumSignificantDigits()),
-        NONE,
         SLOPPY).Assert();
   }
 
   // Set the locale
   char result[ULOC_FULLNAME_CAPACITY];
   status = U_ZERO_ERROR;
   uloc_toLanguageTag(
       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
   if (U_SUCCESS(status)) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromAsciiChecked(result),
-        NONE,
         SLOPPY).Assert();
   } else {
     // This would never happen, since we got the locale from ICU.
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromStaticAscii("und"),
-        NONE,
         SLOPPY).Assert();
   }
 }
 
 
 icu::Collator* CreateICUCollator(
     Isolate* isolate,
     const icu::Locale& icu_locale,
     Handle<JSObject> options) {
   // Make collator from options.
@@ skipping 61 matching lines @@
                                  icu::Collator* collator,
                                  Handle<JSObject> resolved) {
   Factory* factory = isolate->factory();
   UErrorCode status = U_ZERO_ERROR;
 
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("numeric"),
       factory->ToBoolean(
           collator->getAttribute(UCOL_NUMERIC_COLLATION, status) == UCOL_ON),
-      NONE,
       SLOPPY).Assert();
 
   switch (collator->getAttribute(UCOL_CASE_FIRST, status)) {
     case UCOL_LOWER_FIRST:
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("caseFirst"),
           factory->NewStringFromStaticAscii("lower"),
-          NONE,
           SLOPPY).Assert();
       break;
     case UCOL_UPPER_FIRST:
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("caseFirst"),
           factory->NewStringFromStaticAscii("upper"),
-          NONE,
           SLOPPY).Assert();
       break;
     default:
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("caseFirst"),
           factory->NewStringFromStaticAscii("false"),
-          NONE,
           SLOPPY).Assert();
   }
 
   switch (collator->getAttribute(UCOL_STRENGTH, status)) {
     case UCOL_PRIMARY: {
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("strength"),
           factory->NewStringFromStaticAscii("primary"),
-          NONE,
           SLOPPY).Assert();
 
       // case level: true + s1 -> case, s1 -> base.
       if (UCOL_ON == collator->getAttribute(UCOL_CASE_LEVEL, status)) {
         JSObject::SetProperty(
             resolved,
             factory->NewStringFromStaticAscii("sensitivity"),
             factory->NewStringFromStaticAscii("case"),
-            NONE,
             SLOPPY).Assert();
       } else {
         JSObject::SetProperty(
             resolved,
             factory->NewStringFromStaticAscii("sensitivity"),
             factory->NewStringFromStaticAscii("base"),
-            NONE,
             SLOPPY).Assert();
       }
       break;
     }
     case UCOL_SECONDARY:
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("strength"),
           factory->NewStringFromStaticAscii("secondary"),
-          NONE,
           SLOPPY).Assert();
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("sensitivity"),
           factory->NewStringFromStaticAscii("accent"),
-          NONE,
           SLOPPY).Assert();
       break;
     case UCOL_TERTIARY:
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("strength"),
           factory->NewStringFromStaticAscii("tertiary"),
-          NONE,
           SLOPPY).Assert();
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("sensitivity"),
           factory->NewStringFromStaticAscii("variant"),
-          NONE,
           SLOPPY).Assert();
       break;
     case UCOL_QUATERNARY:
       // We shouldn't get quaternary and identical from ICU, but if we do
       // put them into variant.
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("strength"),
           factory->NewStringFromStaticAscii("quaternary"),
-          NONE,
           SLOPPY).Assert();
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("sensitivity"),
           factory->NewStringFromStaticAscii("variant"),
-          NONE,
           SLOPPY).Assert();
       break;
     default:
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("strength"),
           factory->NewStringFromStaticAscii("identical"),
-          NONE,
           SLOPPY).Assert();
       JSObject::SetProperty(
           resolved,
           factory->NewStringFromStaticAscii("sensitivity"),
           factory->NewStringFromStaticAscii("variant"),
-          NONE,
           SLOPPY).Assert();
   }
 
   JSObject::SetProperty(
       resolved,
       factory->NewStringFromStaticAscii("ignorePunctuation"),
       factory->ToBoolean(collator->getAttribute(
           UCOL_ALTERNATE_HANDLING, status) == UCOL_SHIFTED),
-      NONE,
       SLOPPY).Assert();
 
   // Set the locale
   char result[ULOC_FULLNAME_CAPACITY];
   status = U_ZERO_ERROR;
   uloc_toLanguageTag(
       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
   if (U_SUCCESS(status)) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromAsciiChecked(result),
-        NONE,
         SLOPPY).Assert();
   } else {
     // This would never happen, since we got the locale from ICU.
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromStaticAscii("und"),
-        NONE,
         SLOPPY).Assert();
   }
 }
 
 
 icu::BreakIterator* CreateICUBreakIterator(
     Isolate* isolate,
     const icu::Locale& icu_locale,
     Handle<JSObject> options) {
   UErrorCode status = U_ZERO_ERROR;
@@ skipping 35 matching lines @@
   // Set the locale
   char result[ULOC_FULLNAME_CAPACITY];
   status = U_ZERO_ERROR;
   uloc_toLanguageTag(
       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
   if (U_SUCCESS(status)) {
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromAsciiChecked(result),
-        NONE,
         SLOPPY).Assert();
   } else {
     // This would never happen, since we got the locale from ICU.
     JSObject::SetProperty(
         resolved,
         factory->NewStringFromStaticAscii("locale"),
         factory->NewStringFromStaticAscii("und"),
-        NONE,
         SLOPPY).Assert();
   }
 }
 
 }  // namespace
 
 
 // static
 Handle<ObjectTemplateInfo> I18N::GetTemplate(Isolate* isolate) {
   return GetEternal<1, i::EternalHandles::I18N_TEMPLATE_ONE>(isolate);
@@ skipping 247 matching lines @@
 
 
 void BreakIterator::DeleteBreakIterator(
     const v8::WeakCallbackData<v8::Value, void>& data) {
   DeleteNativeObjectAt<icu::BreakIterator>(data, 0);
   DeleteNativeObjectAt<icu::UnicodeString>(data, 1);
   DestroyGlobalHandle(data);
 }
 
 } }  // namespace v8::internal