Hello community, here is the log from the commit of package chromium for openSUSE:Factory checked in at 2020-12-08 13:22:57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/chromium (Old) and /work/SRC/openSUSE:Factory/.chromium.new.5913 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "chromium" Tue Dec 8 13:22:57 2020 rev:277 rq:853253 version:87.0.4280.88 Changes: -------- --- /work/SRC/openSUSE:Factory/chromium/chromium.changes 2020-12-03 18:38:24.905719600 +0100 +++ /work/SRC/openSUSE:Factory/.chromium.new.5913/chromium.changes 2020-12-08 13:25:06.706625669 +0100 @@ -1,0 +2,14 @@ +Fri Dec 4 15:24:58 UTC 2020 - Callum Farmer <[email protected]> + +- Added patches: + - chromium-87-icu68.patch + - chromium-87-v8-icu68.patch +- Update to 87.0.4280.88 bsc#1179576 + - CVE-2020-16037: Use after free in clipboard + - CVE-2020-16038: Use after free in media + - CVE-2020-16039: Use after free in extensions + - CVE-2020-16040: Insufficient data validation in V8 + - CVE-2020-16041: Out of bounds read in networking + - CVE-2020-16042: Uninitialized Use in V8 + +------------------------------------------------------------------- Old: ---- chromium-87.0.4280.66.tar.xz New: ---- chromium-87-icu68.patch chromium-87-v8-icu68.patch chromium-87.0.4280.88.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ chromium.spec ++++++ --- /var/tmp/diff_new_pack.CJwCiL/_old 2020-12-08 13:25:16.674654107 +0100 +++ /var/tmp/diff_new_pack.CJwCiL/_new 2020-12-08 13:25:16.678654119 +0100 @@ -49,7 +49,7 @@ %endif %bcond_with clang Name: chromium -Version: 87.0.4280.66 +Version: 87.0.4280.88 Release: 0 Summary: Google's open source browser project License: BSD-3-Clause AND LGPL-2.1-or-later @@ -101,6 +101,8 @@ Patch66: chromium-87-ozone-deps.patch Patch67: chromium-87-webcodecs-deps.patch Patch68: chromium-lp152-missing-includes.patch +Patch69: chromium-87-v8-icu68.patch +Patch70: chromium-87-icu68.patch # Google seem not too keen on merging this but GPU accel is quite important # https://chromium-review.googlesource.com/c/chromium/src/+/532294 # https://github.com/saiarcot895/chromium-ubuntu-build/tree/master/debian/patches ++++++ chromium-87-icu68.patch ++++++ From 4d16e52a5e6771c4aa5f892e14486bf0e87027d1 Mon Sep 17 00:00:00 2001 From: Frank Tang <[email protected]> Date: Tue, 20 Oct 2020 00:11:50 +0000 Subject: [PATCH] Prepare for landing ICU68 In the landing process of ICU68 we found these need to be changed since ICU68 no longer define TRUE and FALSE for UBool to avoid C++20 problem. Bug: 1138555 Change-Id: I64fd98c99864aa86b07280537a780105cb0eabbe Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2473522 Reviewed-by: Frank Tang <[email protected]> Reviewed-by: Colin Blundell <[email protected]> Reviewed-by: Dominic Battré <[email protected]> Reviewed-by: Guillaume Jenkins <[email protected]> Reviewed-by: Jungshik Shin <[email protected]> Reviewed-by: Mihai Sardarescu <[email protected]> Reviewed-by: Dave Tapuska <[email protected]> Reviewed-by: Mustafa Emre Acer <[email protected]> Reviewed-by: Marian Fechete <[email protected]> Reviewed-by: Matthew Denton <[email protected]> Commit-Queue: Frank Tang <[email protected]> Cr-Commit-Position: refs/heads/master@{#818713} --- diff --git a/base/i18n/icu_util.cc b/base/i18n/icu_util.cc index b225f1d..20debbe 100644 --- a/base/i18n/icu_util.cc +++ b/base/i18n/icu_util.cc @@ -327,7 +327,7 @@ // https://ssl.icu-project.org/trac/ticket/13208 . string16 zone_id = android::GetDefaultTimeZoneId(); icu::TimeZone::adoptDefault(icu::TimeZone::createTimeZone( - icu::UnicodeString(FALSE, zone_id.data(), zone_id.length()))); + icu::UnicodeString(false, zone_id.data(), zone_id.length()))); #elif defined(OS_FUCHSIA) // The platform-specific mechanisms used by ICU's detectHostTimeZone() to // determine the default time zone will not work on Fuchsia. Therefore, diff --git a/base/i18n/string_compare.cc b/base/i18n/string_compare.cc index c0e83c6..e4fb687 100644 --- a/base/i18n/string_compare.cc +++ b/base/i18n/string_compare.cc @@ -18,8 +18,8 @@ StringPiece16 rhs) { UErrorCode error = U_ZERO_ERROR; UCollationResult result = collator.compare( - icu::UnicodeString(FALSE, lhs.data(), static_cast<int>(lhs.length())), - icu::UnicodeString(FALSE, rhs.data(), static_cast<int>(rhs.length())), + icu::UnicodeString(false, lhs.data(), static_cast<int>(lhs.length())), + icu::UnicodeString(false, rhs.data(), static_cast<int>(rhs.length())), error); DCHECK(U_SUCCESS(error)); return result; diff --git a/base/i18n/time_formatting.cc b/base/i18n/time_formatting.cc index c769b57..c085f5e 100644 --- a/base/i18n/time_formatting.cc +++ b/base/i18n/time_formatting.cc @@ -240,7 +240,7 @@ icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE); measure_format.formatMeasures(measures, 3, formatted, ignore, status); *out = i18n::UnicodeStringToString16(formatted); - return U_SUCCESS(status) == TRUE; + return U_SUCCESS(status); } string16 DateIntervalFormat(const Time& begin_time, diff --git a/components/autofill/core/common/autofill_regexes.cc b/components/autofill/core/common/autofill_regexes.cc index 02254fa..1cf12f3 100644 --- a/components/autofill/core/common/autofill_regexes.cc +++ b/components/autofill/core/common/autofill_regexes.cc @@ -43,7 +43,7 @@ icu::RegexMatcher* AutofillRegexes::GetMatcher(const base::string16& pattern) { auto it = matchers_.find(pattern); if (it == matchers_.end()) { - const icu::UnicodeString icu_pattern(FALSE, pattern.data(), + const icu::UnicodeString icu_pattern(false, pattern.data(), pattern.length()); UErrorCode status = U_ZERO_ERROR; @@ -71,21 +71,21 @@ base::AutoLock lock(*g_lock); icu::RegexMatcher* matcher = g_autofill_regexes->GetMatcher(pattern); - icu::UnicodeString icu_input(FALSE, input.data(), input.length()); + icu::UnicodeString icu_input(false, input.data(), input.length()); matcher->reset(icu_input); UErrorCode status = U_ZERO_ERROR; UBool matched = matcher->find(0, status); DCHECK(U_SUCCESS(status)); - if (matched == TRUE && match) { + if (matched && match) { icu::UnicodeString match_unicode = matcher->group(group_to_be_captured, status); DCHECK(U_SUCCESS(status)); *match = base::i18n::UnicodeStringToString16(match_unicode); } - return matched == TRUE; + return matched; } } // namespace autofill diff --git a/components/autofill_assistant/browser/string_conversions_util.cc b/components/autofill_assistant/browser/string_conversions_util.cc index 212bafa..1d00d68 100644 --- a/components/autofill_assistant/browser/string_conversions_util.cc +++ b/components/autofill_assistant/browser/string_conversions_util.cc @@ -39,13 +39,13 @@ // |target|. bool AppendUnicodeToUTF8(const UChar32 source, std::string* target) { char bytes[4]; - UBool error = FALSE; + UBool error = false; size_t offset = 0; U8_APPEND(bytes, offset, base::size(bytes), source, error); - if (error == FALSE) { + if (error == false) { target->append(bytes, offset); } - return error == FALSE; + return !error; } } // namespace autofill_assistant diff --git a/components/signin/public/identity_manager/identity_utils.cc b/components/signin/public/identity_manager/identity_utils.cc index 1c414e2..014d674 100644 --- a/components/signin/public/identity_manager/identity_utils.cc +++ b/components/signin/public/identity_manager/identity_utils.cc @@ -33,7 +33,7 @@ // See if the username matches the policy-provided pattern. UErrorCode status = U_ZERO_ERROR; - const icu::UnicodeString icu_pattern(FALSE, utf16_pattern.data(), + const icu::UnicodeString icu_pattern(false, utf16_pattern.data(), utf16_pattern.length()); icu::RegexMatcher matcher(icu_pattern, UREGEX_CASE_INSENSITIVE, status); if (!U_SUCCESS(status)) { diff --git a/components/spellcheck/renderer/spellcheck_worditerator.cc b/components/spellcheck/renderer/spellcheck_worditerator.cc index ec16fef..3b1f060 100644 --- a/components/spellcheck/renderer/spellcheck_worditerator.cc +++ b/components/spellcheck/renderer/spellcheck_worditerator.cc @@ -442,7 +442,7 @@ // spellchecker and we need manual normalization as well. The normalized // text does not have to be NUL-terminated since its characters are copied to // string16, which adds a NUL character when we need. - icu::UnicodeString input(FALSE, &text_[input_start], + icu::UnicodeString input(false, &text_[input_start], base::checked_cast<int32_t>(input_length)); UErrorCode status = U_ZERO_ERROR; icu::UnicodeString output; diff --git a/components/url_formatter/spoof_checks/idn_spoof_checker.cc b/components/url_formatter/spoof_checks/idn_spoof_checker.cc index 6d66a7c..d73192b1 100644 --- a/components/url_formatter/spoof_checks/idn_spoof_checker.cc +++ b/components/url_formatter/spoof_checks/idn_spoof_checker.cc @@ -368,7 +368,7 @@ return Result::kICUSpoofChecks; } - icu::UnicodeString label_string(FALSE /* isTerminated */, label.data(), + icu::UnicodeString label_string(false /* isTerminated */, label.data(), base::checked_cast<int32_t>(label.size())); // A punycode label with 'xn--' prefix is not subject to the URL @@ -711,7 +711,7 @@ base::StringPiece tld, base::StringPiece16 tld_unicode) { icu::UnicodeString tld_string( - FALSE /* isTerminated */, tld_unicode.data(), + false /* isTerminated */, tld_unicode.data(), base::checked_cast<int32_t>(tld_unicode.size())); // Allow if the TLD contains any letter from the script, in which case it's // likely to be a TLD in that script. diff --git a/components/url_formatter/spoof_checks/skeleton_generator.cc b/components/url_formatter/spoof_checks/skeleton_generator.cc index 9628626..9a77901 100644 --- a/components/url_formatter/spoof_checks/skeleton_generator.cc +++ b/components/url_formatter/spoof_checks/skeleton_generator.cc @@ -116,7 +116,7 @@ Skeletons SkeletonGenerator::GetSkeletons(base::StringPiece16 hostname) { Skeletons skeletons; size_t hostname_length = hostname.length() - (hostname.back() == '.' ? 1 : 0); - icu::UnicodeString host(FALSE, hostname.data(), hostname_length); + icu::UnicodeString host(false, hostname.data(), hostname_length); // If input has any characters outside Latin-Greek-Cyrillic and [0-9._-], // there is no point in getting rid of diacritics because combining marks // attached to non-LGC characters are already blocked. diff --git a/content/zygote/zygote_linux.cc b/content/zygote/zygote_linux.cc index 95d5a82..b6d8e5a 100644 --- a/content/zygote/zygote_linux.cc +++ b/content/zygote/zygote_linux.cc @@ -557,7 +557,7 @@ if (!iter.ReadString16(&timezone_id)) return -1; icu::TimeZone::adoptDefault(icu::TimeZone::createTimeZone( - icu::UnicodeString(FALSE, timezone_id.data(), timezone_id.length()))); + icu::UnicodeString(false, timezone_id.data(), timezone_id.length()))); if (!iter.ReadInt(&numfds)) return -1; diff --git a/services/device/time_zone_monitor/time_zone_monitor_android.cc b/services/device/time_zone_monitor/time_zone_monitor_android.cc index 818670a..f57f972 100644 --- a/services/device/time_zone_monitor/time_zone_monitor_android.cc +++ b/services/device/time_zone_monitor/time_zone_monitor_android.cc @@ -34,7 +34,7 @@ // See base/i18n/icu_util.cc:InitializeIcuTimeZone() for more information. base::string16 zone_id = base::android::GetDefaultTimeZoneId(); std::unique_ptr<icu::TimeZone> new_zone(icu::TimeZone::createTimeZone( - icu::UnicodeString(FALSE, zone_id.data(), zone_id.length()))); + icu::UnicodeString(false, zone_id.data(), zone_id.length()))); UpdateIcuAndNotifyClients(std::move(new_zone)); } diff --git a/third_party/blink/renderer/core/exported/web_view_test.cc b/third_party/blink/renderer/core/exported/web_view_test.cc index a6b9552..36809d91 100644 --- a/third_party/blink/renderer/core/exported/web_view_test.cc +++ b/third_party/blink/renderer/core/exported/web_view_test.cc @@ -4868,18 +4868,18 @@ TEST_F(ShowUnhandledTapTest, ShowUnhandledTapUIIfNeededWithMutateDom) { // Test dom mutation. - TestEachMouseEvent("mutateDom", FALSE); + TestEachMouseEvent("mutateDom", false); // Test without any DOM mutation. - TestEachMouseEvent("none", TRUE); + TestEachMouseEvent("none", true); } TEST_F(ShowUnhandledTapTest, ShowUnhandledTapUIIfNeededWithMutateStyle) { // Test style mutation. - TestEachMouseEvent("mutateStyle", FALSE); + TestEachMouseEvent("mutateStyle", false); // Test checkbox:indeterminate style mutation. - TestEachMouseEvent("mutateIndeterminate", FALSE); + TestEachMouseEvent("mutateIndeterminate", false); // Test click div with :active style. Tap("style_active"); @@ -4888,10 +4888,10 @@ TEST_F(ShowUnhandledTapTest, ShowUnhandledTapUIIfNeededWithPreventDefault) { // Test swallowing. - TestEachMouseEvent("preventDefault", FALSE); + TestEachMouseEvent("preventDefault", false); // Test without any preventDefault. - TestEachMouseEvent("none", TRUE); + TestEachMouseEvent("none", true); } TEST_F(ShowUnhandledTapTest, ShowUnhandledTapUIIfNeededWithNonTriggeringNodes) { diff --git a/third_party/blink/renderer/platform/text/locale_icu.cc b/third_party/blink/renderer/platform/text/locale_icu.cc index 92fb99e0..f991b51 100644 --- a/third_party/blink/renderer/platform/text/locale_icu.cc +++ b/third_party/blink/renderer/platform/text/locale_icu.cc @@ -169,12 +169,12 @@ return g_empty_string; UErrorCode status = U_ZERO_ERROR; - int32_t length = udat_toPattern(date_format, TRUE, nullptr, 0, &status); + int32_t length = udat_toPattern(date_format, true, nullptr, 0, &status); if (status != U_BUFFER_OVERFLOW_ERROR || !length) return g_empty_string; StringBuffer<UChar> buffer(length); status = U_ZERO_ERROR; - udat_toPattern(date_format, TRUE, buffer.Characters(), length, &status); + udat_toPattern(date_format, true, buffer.Characters(), length, &status); if (U_FAILURE(status)) return g_empty_string; return String::Adopt(buffer); diff --git a/third_party/blink/renderer/platform/text/text_break_iterator_icu.cc b/third_party/blink/renderer/platform/text/text_break_iterator_icu.cc index 5bea007..0e8c60a 100644 --- a/third_party/blink/renderer/platform/text/text_break_iterator_icu.cc +++ b/third_party/blink/renderer/platform/text/text_break_iterator_icu.cc @@ -312,13 +312,13 @@ text->chunkOffset = offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0; - is_accessible = TRUE; + is_accessible = true; return true; } if (native_index >= native_length && text->chunkNativeLimit == native_length) { text->chunkOffset = text->chunkLength; - is_accessible = FALSE; + is_accessible = false; return true; } } else { @@ -331,12 +331,12 @@ text->chunkOffset = offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0; - is_accessible = TRUE; + is_accessible = true; return true; } if (native_index <= 0 && !text->chunkNativeStart) { text->chunkOffset = 0; - is_accessible = FALSE; + is_accessible = false; return true; } } @@ -347,7 +347,7 @@ int64_t native_index, UBool forward) { if (!text->context) - return FALSE; + return false; int64_t native_length = TextNativeLength(text); UBool is_accessible; if (TextInChunkOrOutOfRange(text, native_index, native_length, forward, @@ -371,7 +371,7 @@ DCHECK_EQ(new_context, kPriorContext); TextLatin1SwitchToPriorContext(text, native_index, native_length, forward); } - return TRUE; + return true; } static const struct UTextFuncs kTextLatin1Funcs = { @@ -511,7 +511,7 @@ static UBool TextUTF16Access(UText* text, int64_t native_index, UBool forward) { if (!text->context) - return FALSE; + return false; int64_t native_length = TextNativeLength(text); UBool is_accessible; if (TextInChunkOrOutOfRange(text, native_index, native_length, forward, @@ -533,7 +533,7 @@ DCHECK_EQ(new_context, kPriorContext); TextUTF16SwitchToPriorContext(text, native_index, native_length, forward); } - return TRUE; + return true; } static const struct UTextFuncs kTextUTF16Funcs = { diff --git a/third_party/blink/renderer/platform/text/unicode_utilities.cc b/third_party/blink/renderer/platform/text/unicode_utilities.cc index 2cefd53..b8c4515 100644 --- a/third_party/blink/renderer/platform/text/unicode_utilities.cc +++ b/third_party/blink/renderer/platform/text/unicode_utilities.cc @@ -300,7 +300,7 @@ DCHECK(U_SUCCESS(status)); int32_t input_length = static_cast<int32_t>(length); // copy-on-write. - icu::UnicodeString normalized(FALSE, characters, input_length); + icu::UnicodeString normalized(false, characters, input_length); // In the vast majority of cases, input is already NFC. Run a quick check // to avoid normalizing the entire input unnecessarily. int32_t normalized_prefix_length = diff --git a/third_party/blink/renderer/platform/wtf/text/text_codec_icu.cc b/third_party/blink/renderer/platform/wtf/text/text_codec_icu.cc index b625735..fb8ab05 100644 --- a/third_party/blink/renderer/platform/wtf/text/text_codec_icu.cc +++ b/third_party/blink/renderer/platform/wtf/text/text_codec_icu.cc @@ -327,7 +327,7 @@ DLOG_IF(ERROR, err == U_AMBIGUOUS_ALIAS_WARNING) << "ICU ambiguous alias warning for encoding: " << encoding_.GetName(); if (converter_icu_) - ucnv_setFallback(converter_icu_, TRUE); + ucnv_setFallback(converter_icu_, true); } int TextCodecICU::DecodeToBuffer(UChar* target, diff --git a/ui/base/l10n/formatter.cc b/ui/base/l10n/formatter.cc index e4446d4..684ead8 100644 --- a/ui/base/l10n/formatter.cc +++ b/ui/base/l10n/formatter.cc @@ -234,7 +234,7 @@ int value, icu::UnicodeString* formatted_string) const { DCHECK(simple_format_[unit]); - DCHECK(formatted_string->isEmpty() == TRUE); + DCHECK(formatted_string->isEmpty()); UErrorCode error = U_ZERO_ERROR; FormatNumberInPlural(*simple_format_[unit], value, formatted_string, &error); @@ -250,7 +250,7 @@ << "Detailed() not implemented for your (format, length) combination!"; DCHECK(detailed_format_[units][1]) << "Detailed() not implemented for your (format, length) combination!"; - DCHECK(formatted_string->isEmpty() == TRUE); + DCHECK(formatted_string->isEmpty()); UErrorCode error = U_ZERO_ERROR; FormatNumberInPlural(*detailed_format_[units][0], value_1, formatted_string, &error); @@ -283,7 +283,7 @@ base::string16 pattern = l10n_util::GetStringUTF16(pluralities.id); UErrorCode error = U_ZERO_ERROR; std::unique_ptr<icu::MessageFormat> format(new icu::MessageFormat( - icu::UnicodeString(FALSE, pattern.data(), pattern.length()), error)); + icu::UnicodeString(false, pattern.data(), pattern.length()), error)); DCHECK(U_SUCCESS(error)); if (format.get()) return format; ++++++ chromium-87-v8-icu68.patch ++++++ From b0a7f5691113534c2cf771f2dd3cece5e93bc7d4 Mon Sep 17 00:00:00 2001 From: Frank Tang <[email protected]> Date: Tue, 03 Nov 2020 23:20:37 -0800 Subject: [PATCH] Update to ICU68-1 ICU68-1 change the output skeleton format. So we need to change resolvedOptions code for 68 migration. Chromium roll https://chromium-review.googlesource.com/c/chromium/src/+/2474093 Bug: v8:10945 Change-Id: I3b2c7fbe8abb22df8fa51287c498ca3245b8c55b Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2477431 Commit-Queue: Frank Tang <[email protected]> Reviewed-by: Jakob Kummerow <[email protected]> Reviewed-by: Shu-yu Guo <[email protected]> Cr-Commit-Position: refs/heads/master@{#70972} (ported to work with <ICU-68.1 and rebased chromium) --- diff --git a/v8/src/objects/js-number-format.cc b/v8/src/objects/js-number-format.cc index 45b0eab..d18b133 100644 --- a/v8/src/objects/js-number-format.cc +++ b/v8/src/objects/js-number-format.cc @@ -389,17 +389,20 @@ Handle<String> CurrencySignString(Isolate* isolate, Handle<String> UnitDisplayString(Isolate* isolate, const icu::UnicodeString& skeleton) { // Ex: skeleton as - // "measure-unit/length-meter .### rounding-mode-half-up unit-width-full-name" + // <ICU-68.1: "measure-unit/length-meter .### rounding-mode-half-up unit-width-full-name". + // >=ICU-68.1: "unit/length-meter .### rounding-mode-half-up unit-width-full-name" if (skeleton.indexOf("unit-width-full-name") >= 0) { return ReadOnlyRoots(isolate).long_string_handle(); } // Ex: skeleton as - // "measure-unit/length-meter .### rounding-mode-half-up unit-width-narrow". + // <ICU-68.1: "measure-unit/length-meter .### rounding-mode-half-up unit-width-narrow". + // >=ICU-68.1: "unit/length-meter .### rounding-mode-half-up unit-width-narrow". if (skeleton.indexOf("unit-width-narrow") >= 0) { return ReadOnlyRoots(isolate).narrow_string_handle(); } // Ex: skeleton as - // "measure-unit/length-foot .### rounding-mode-half-up" + // <ICU-68.1: "measure-unit/length-foot .### rounding-mode-half-up" + // >=ICU-68.1: "unit/length-foot .### rounding-mode-half-up" return ReadOnlyRoots(isolate).short_string_handle(); } @@ -422,7 +425,8 @@ Notation NotationFromSkeleton(const icu::UnicodeString& skeleton) { return Notation::COMPACT; } // Ex: skeleton as - // "measure-unit/length-foot .### rounding-mode-half-up" + // <ICU-68.1: "measure-unit/length-foot .### rounding-mode-half-up" + // >=ICU-68.1: "unit/length-foot .### rounding-mode-half-up" return Notation::STANDARD; } @@ -562,14 +566,23 @@ namespace { // Ex: percent .### rounding-mode-half-up // Special case for "percent" -// Ex: "measure-unit/length-kilometer per-measure-unit/duration-hour .### -// rounding-mode-half-up" should return "kilometer-per-unit". -// Ex: "measure-unit/duration-year .### rounding-mode-half-up" should return -// "year". +// <ICU-68.1: +// Ex: "measure-unit/length-kilometer per-measure-unit/duration-hour .### +// rounding-mode-half-up" should return "kilometer-per-unit". +// Ex: "measure-unit/duration-year .### rounding-mode-half-up" should return +// >=ICU-68.1: +// Ex: "unit/milliliter-per-acre .### rounding-mode-half-up" +// should return "milliliter-per-acre". +// Ex: "unit/year .### rounding-mode-half-up" should return +// "year". std::string UnitFromSkeleton(const icu::UnicodeString& skeleton) { std::string str; str = skeleton.toUTF8String<std::string>(str); +#if U_ICU_VERSION_MAJOR_NUM < 68 std::string search("measure-unit/"); +#else + std::string search("unit/"); +#endif size_t begin = str.find(search); if (begin == str.npos) { // Special case for "percent". @@ -578,20 +591,41 @@ std::string UnitFromSkeleton(const icu::UnicodeString& skeleton) { } return ""; } +#if U_ICU_VERSION_MAJOR_NUM < 68 // Skip the type (ex: "length"). // "measure-unit/length-kilometer per-measure-unit/duration-hour" // b begin = str.find("-", begin + search.size()); +#else + // Ex: + // "unit/acre .### rounding-mode-half-up" + // b + // Ex: + // "unit/milliliter-per-acre .### rounding-mode-half-up" + // b + begin += search.size(); +#endif if (begin == str.npos) { return ""; } +#if U_ICU_VERSION_MAJOR_NUM < 68 begin++; // Skip the '-'. +#endif // Find the end of the subtype. size_t end = str.find(" ", begin); - // "measure-unit/length-kilometer per-measure-unit/duration-hour" - // b e + // <ICU-68.1: + // "measure-unit/length-kilometer per-measure-unit/duration-hour" + // b e + // >=ICU-68.1: + // Ex: + // "unit/acre .### rounding-mode-half-up" + // b e + // Ex: + // "unit/milliliter-per-acre .### rounding-mode-half-up" + // b e if (end == str.npos) { end = str.size(); +#if U_ICU_VERSION_MAJOR_NUM < 68 return str.substr(begin, end - begin); } // "measure-unit/length-kilometer per-measure-unit/duration-hour" @@ -625,17 +659,36 @@ std::string UnitFromSkeleton(const icu::UnicodeString& skeleton) { // "measure-unit/length-kilometer per-measure-unit/duration-hour" // [result ] b e return result + "-per-" + str.substr(begin, end - begin); +#else + } + return str.substr(begin, end - begin); +#endif } Style StyleFromSkeleton(const icu::UnicodeString& skeleton) { if (skeleton.indexOf("currency/") >= 0) { return Style::CURRENCY; } +#if U_ICU_VERSION_MAJOR_NUM < 68 if (skeleton.indexOf("measure-unit/") >= 0) { if (skeleton.indexOf("scale/100") >= 0 && skeleton.indexOf("measure-unit/concentr-percent") >= 0) { +#else + if (skeleton.indexOf("percent") >= 0) { + // percent precision-integer rounding-mode-half-up scale/100 + if (skeleton.indexOf("scale/100") >= 0) { +#endif return Style::PERCENT; +#if U_ICU_VERSION_MAJOR_NUM >= 68 + } else { + return Style::UNIT; +#endif } +#if U_ICU_VERSION_MAJOR_NUM >= 68 + } + // Before ICU68: "measure-unit/", since ICU68 "unit/" + if (skeleton.indexOf("unit/") >= 0) { +#endif return Style::UNIT; } return Style::DECIMAL; diff --git a/v8/src/objects/js-relative-time-format.cc b/v8/src/objects/js-relative-time-format.cc index 267343aaae..64d56a1c12 100644 --- a/v8/src/objects/js-relative-time-format.cc +++ b/v8/src/objects/js-relative-time-format.cc @@ -195,9 +195,18 @@ MaybeHandle<JSRelativeTimeFormat> JSRelativeTimeFormat::New( } } +#if U_ICU_VERSION_MAJOR_NUM < 68 icu::DecimalFormat* decimal_format = static_cast<icu::DecimalFormat*>(number_format); decimal_format->setMinimumGroupingDigits(-2); +#else + if (number_format->getDynamicClassID() == + icu::DecimalFormat::getStaticClassID()) { + icu::DecimalFormat* decimal_format = + static_cast<icu::DecimalFormat*>(number_format); + decimal_format->setMinimumGroupingDigits(-2); + } +#endif // Change UDISPCTX_CAPITALIZATION_NONE to other values if // ECMA402 later include option to change capitalization. ++++++ chromium-87.0.4280.66.tar.xz -> chromium-87.0.4280.88.tar.xz ++++++ /work/SRC/openSUSE:Factory/chromium/chromium-87.0.4280.66.tar.xz /work/SRC/openSUSE:Factory/.chromium.new.5913/chromium-87.0.4280.88.tar.xz differ: char 27, line 1 _______________________________________________ openSUSE Commits mailing list -- [email protected] To unsubscribe, email [email protected] List Netiquette: https://en.opensuse.org/openSUSE:Mailing_list_netiquette List Archives: https://lists.opensuse.org/archives/list/[email protected]
