diff --git a/chromium-71.0.3578.98-gcc9-drop-rsp-clobber.patch b/chromium-71.0.3578.98-gcc9-drop-rsp-clobber.patch deleted file mode 100644 index d071e814..00000000 --- a/chromium-71.0.3578.98-gcc9-drop-rsp-clobber.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -up chromium-71.0.3578.98/third_party/tcmalloc/gperftools-2.0/chromium/src/base/linux_syscall_support.h.gcc9 chromium-71.0.3578.98/third_party/tcmalloc/gperftools-2.0/chromium/src/base/linux_syscall_support.h ---- chromium-71.0.3578.98/third_party/tcmalloc/gperftools-2.0/chromium/src/base/linux_syscall_support.h.gcc9 2019-01-08 13:27:25.193614727 -0500 -+++ chromium-71.0.3578.98/third_party/tcmalloc/gperftools-2.0/chromium/src/base/linux_syscall_support.h 2019-01-08 13:27:35.161392234 -0500 -@@ -1231,7 +1231,7 @@ typedef unsigned long int ulong; - "d"(LSS_SYSCALL_ARG(parent_tidptr)), - "r"(LSS_SYSCALL_ARG(newtls)), - "r"(LSS_SYSCALL_ARG(child_tidptr)) -- : "rsp", "memory", "r8", "r10", "r11", "rcx"); -+ : "memory", "r8", "r10", "r11", "rcx"); - } - LSS_RETURN(int, __res); - } diff --git a/chromium-76.0.3809.132-chromedriver-zlib-fix.patch b/chromium-76.0.3809.132-chromedriver-zlib-fix.patch new file mode 100644 index 00000000..f8b44d03 --- /dev/null +++ b/chromium-76.0.3809.132-chromedriver-zlib-fix.patch @@ -0,0 +1,11 @@ +diff -up chromium-76.0.3809.132/chrome/test/chromedriver/BUILD.gn.fixme chromium-76.0.3809.132/chrome/test/chromedriver/BUILD.gn +--- chromium-76.0.3809.132/chrome/test/chromedriver/BUILD.gn.fixme 2019-09-10 15:53:02.871463568 -0400 ++++ chromium-76.0.3809.132/chrome/test/chromedriver/BUILD.gn 2019-09-10 16:57:32.281112323 -0400 +@@ -319,6 +319,7 @@ executable("chromedriver") { + "//net/server:http_server", + "//net/traffic_annotation:test_support", + "//services/network/public/mojom", ++ "//third_party/zlib", + ] + } + diff --git a/chromium-76.0.3809.132-rhel8-force-disable-use_gnome_keyring.patch b/chromium-76.0.3809.132-rhel8-force-disable-use_gnome_keyring.patch new file mode 100644 index 00000000..ff6c5236 --- /dev/null +++ b/chromium-76.0.3809.132-rhel8-force-disable-use_gnome_keyring.patch @@ -0,0 +1,10 @@ +diff -up chromium-76.0.3809.132/components/os_crypt/features.gni.rhel8 chromium-76.0.3809.132/components/os_crypt/features.gni +--- chromium-76.0.3809.132/components/os_crypt/features.gni.rhel8 2019-09-06 17:08:01.242314126 -0400 ++++ chromium-76.0.3809.132/components/os_crypt/features.gni 2019-09-06 17:08:10.139134707 -0400 +@@ -7,5 +7,5 @@ import("//build/config/ui.gni") + declare_args() { + # Whether to use libgnome-keyring (deprecated by libsecret). + # See http://crbug.com/466975 and http://crbug.com/355223. +- use_gnome_keyring = is_desktop_linux && use_glib ++ use_gnome_keyring = false + } diff --git a/chromium-77-clang.patch b/chromium-77-clang.patch new file mode 100644 index 00000000..a57b5a45 --- /dev/null +++ b/chromium-77-clang.patch @@ -0,0 +1,13 @@ +diff --git a/base/location.h b/base/location.h +index c07e747..924db1c 100644 +--- a/base/location.h ++++ b/base/location.h +@@ -18,7 +18,7 @@ + + namespace base { + +-#if defined(__has_builtin) ++#if defined(__clang__) + // Clang allows detection of these builtins. + #define SUPPORTS_LOCATION_BUILTINS \ + (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \ diff --git a/chromium-77.0.3865.120-gcc-fix-zlib-symbol-visibility.patch b/chromium-77.0.3865.120-gcc-fix-zlib-symbol-visibility.patch new file mode 100644 index 00000000..47fd97d5 --- /dev/null +++ b/chromium-77.0.3865.120-gcc-fix-zlib-symbol-visibility.patch @@ -0,0 +1,36 @@ +From 9c3aed099b010a75594a0efd523774c4c9a5e3d2 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?J=C3=BCri=20Valdmann?= +Date: Tue, 15 Oct 2019 12:10:55 +0000 +Subject: [PATCH] GCC: Fix zlib symbol visibility macro + +GCC parses the function __attribute__ syntax a bit differently from Clang, +associating the attribute with the return type instead of the function if the +return type is a pointer. This leads to certain zlib symbols, such as +Cr_z_zError, to fail to be properly exported from the shared library. Fix by +using ZEXTERN instead of ZEXPORT for the attribute which works the same for both +GCC and Clang. + +Bug: 819294 +Change-Id: I5707d1b0627a503df08df9ac0bb65fda69453989 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1859788 +Reviewed-by: Thomas Anderson +Reviewed-by: Nico Weber +Commit-Queue: Nico Weber +Cr-Commit-Position: refs/heads/master@{#705917} +--- + third_party/zlib/chromeconf.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/third_party/zlib/chromeconf.h b/third_party/zlib/chromeconf.h +index e9aa3867d8512..666093d696a58 100644 +--- a/third_party/zlib/chromeconf.h ++++ b/third_party/zlib/chromeconf.h +@@ -13,7 +13,7 @@ + #define ZEXTERN __declspec(dllimport) + #endif + #elif defined(ZLIB_IMPLEMENTATION) +-#define ZEXPORT __attribute__((visibility("default"))) ++#define ZEXTERN __attribute__((visibility("default"))) + #endif + #endif + diff --git a/chromium-77.0.3865.120-silence-outdated-build-noise.patch b/chromium-77.0.3865.120-silence-outdated-build-noise.patch new file mode 100644 index 00000000..f2d47355 --- /dev/null +++ b/chromium-77.0.3865.120-silence-outdated-build-noise.patch @@ -0,0 +1,60 @@ +From e79d9d0e06b825d2e62b38db03248c0e6ceec7e4 Mon Sep 17 00:00:00 2001 +From: Greg Thompson +Date: Sat, 5 Oct 2019 03:47:05 +0000 +Subject: [PATCH] Only detect outdated builds on Google Chrome. + +Prior to https://crrev.com/643864, they weren't detected for Chromium on +account of the way google_brand worked. That CL changed behavior and +accidentally started showing the outdated build bubble for Linux +Chromium users. + +BUG=1010592 + +Change-Id: I069ac36166e2ae720d58b1b9aa85605792be8684 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1841635 +Reviewed-by: Thomas Anderson +Reviewed-by: Lei Zhang +Commit-Queue: Greg Thompson +Cr-Commit-Position: refs/heads/master@{#703131} +--- + .../upgrade_detector/upgrade_detector_impl.cc | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/chrome/browser/upgrade_detector/upgrade_detector_impl.cc b/chrome/browser/upgrade_detector/upgrade_detector_impl.cc +index 432e3789eced0..07850fdf80cd7 100644 +--- a/chrome/browser/upgrade_detector/upgrade_detector_impl.cc ++++ b/chrome/browser/upgrade_detector/upgrade_detector_impl.cc +@@ -31,6 +31,7 @@ + #include "base/time/default_tick_clock.h" + #include "base/time/tick_clock.h" + #include "base/time/time.h" ++#include "build/branding_buildflags.h" + #include "chrome/browser/browser_process.h" + #include "chrome/browser/google/google_brand.h" + #include "chrome/common/chrome_switches.h" +@@ -73,6 +74,14 @@ constexpr base::TimeDelta kNotifyCycleTimeForTesting = + // The number of days after which we identify a build/install as outdated. + constexpr base::TimeDelta kOutdatedBuildAge = base::TimeDelta::FromDays(12 * 7); + ++constexpr bool ShouldDetectOutdatedBuilds() { ++#if BUILDFLAG(GOOGLE_CHROME_BRANDING) ++ return true; ++#else // BUILDFLAG(GOOGLE_CHROME_BRANDING) ++ return false; ++#endif // BUILDFLAG(GOOGLE_CHROME_BRANDING) ++} ++ + // Return the string that was passed as a value for the + // kCheckForUpdateIntervalSec switch. + std::string CmdLineInterval() { +@@ -406,6 +415,10 @@ bool UpgradeDetectorImpl::DetectOutdated + return false; + } + #endif ++ ++ if (!ShouldDetectOutdatedBuilds()) ++ return false; ++ + } + + base::Time network_time; diff --git a/chromium-78-gcc-noexcept.patch b/chromium-78-gcc-noexcept.patch new file mode 100644 index 00000000..8ddb53fe --- /dev/null +++ b/chromium-78-gcc-noexcept.patch @@ -0,0 +1,32 @@ +From d16cda8fc3476cc534a756873cc8aa2692a57054 Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz +Date: Thu, 22 Aug 2019 13:13:36 +0200 +Subject: [PATCH] GCC: declare noexcept move constructor/assign operators of V8StackTraceId + +blink::BlinkCloneableMessage declares default implementation of +move operator/assign operator that requires v8_inspector::V8StackTraceId +to declare its move constructor/assign operator too. + +Bug: chromium:819294 +Change-Id: Iaf626ee8245efcba372a17cdf2de448e691d41d6 +Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1796062 +Commit-Queue: José Dapena Paz +Reviewed-by: Yang Guo +Cr-Commit-Position: refs/heads/master@{#63799} +--- + +diff --git a/v8/include/v8-inspector.h b/v8/include/v8-inspector.h +index ce5b777..ed4cdec 100644 +--- a/v8/include/v8-inspector.h ++++ b/v8/include/v8-inspector.h +@@ -231,7 +231,10 @@ struct V8_EXPORT V8StackTraceId { + std::pair debugger_id; + + V8StackTraceId(); ++ V8StackTraceId(const V8StackTraceId&) = default; + V8StackTraceId(uintptr_t id, const std::pair debugger_id); ++ V8StackTraceId& operator=(const V8StackTraceId&) = default; ++ V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default; + ~V8StackTraceId() = default; + + bool IsInvalid() const; diff --git a/chromium-78-include.patch b/chromium-78-include.patch new file mode 100644 index 00000000..3db38eac --- /dev/null +++ b/chromium-78-include.patch @@ -0,0 +1,40 @@ +From bbfe2665923225b4a7c436ba2b6c7e5f695f2e52 Mon Sep 17 00:00:00 2001 +From: David Landell +Date: Fri, 13 Sep 2019 12:24:13 +0000 +Subject: [PATCH] Add missing include for unique_ptr + +Change-Id: I614d2f42868d563eb6a92dfb2aae08286e20d687 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1803137 +Reviewed-by: Henrik Boström +Commit-Queue: Henrik Boström +Cr-Commit-Position: refs/heads/master@{#696355} +--- + +diff --git a/third_party/blink/public/platform/web_rtc_rtp_source.h b/third_party/blink/public/platform/web_rtc_rtp_source.h +index 959440f..c3fd542 100644 +--- a/third_party/blink/public/platform/web_rtc_rtp_source.h ++++ b/third_party/blink/public/platform/web_rtc_rtp_source.h +@@ -5,6 +5,8 @@ + #ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_RTC_RTP_SOURCE_H_ + #define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_RTC_RTP_SOURCE_H_ + ++#include ++ + #include "base/optional.h" + #include "third_party/blink/public/platform/web_common.h" + +Missing include due to reverting ProfileManagerObserver +--- + +diff --git a/chrome/browser/web_applications/extensions/bookmark_app_util.cc b/chrome/browser/web_applications/extensions/bookmark_app_util.cc +index ee4b70a..b31e5f5 100644 +--- a/chrome/browser/web_applications/extensions/bookmark_app_util.cc ++++ b/chrome/browser/web_applications/extensions/bookmark_app_util.cc +@@ -7,6 +7,7 @@ + #include "base/strings/string_piece.h" + #include "base/values.h" + #include "chrome/browser/extensions/extension_service.h" ++#include "chrome/browser/profiles/profile.h" + #include "chrome/browser/web_applications/components/app_registrar.h" + #include "chrome/browser/web_applications/components/web_app_provider_base.h" + #include "chrome/common/chrome_features.h" diff --git a/chromium-78-pm-crash.patch b/chromium-78-pm-crash.patch new file mode 100644 index 00000000..ada26612 --- /dev/null +++ b/chromium-78-pm-crash.patch @@ -0,0 +1,43 @@ +From e73aed9a5ef15102f29ac31b70290faf5c90f9fe Mon Sep 17 00:00:00 2001 +From: Evan Stade +Date: Wed, 16 Oct 2019 16:01:32 +0000 +Subject: [PATCH] Fix shutdown crash in ProfileManager. + +OnProfileMarkedForPermanentDeletion should move from +ProfileManagerObserver to ProfileObserver, which would also +fix this bug. However, changing the order of members is the +quickest and most cherry-pick-able way to avoid the crash. + +Bug: 1005244 +Change-Id: If2db68c846dd418cd02864b57b9b543687fa1e03 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863518 +Auto-Submit: Evan Stade +Reviewed-by: David Roger +Commit-Queue: Evan Stade +Cr-Commit-Position: refs/heads/master@{#706467} +--- + +diff --git a/chrome/browser/profiles/profile_manager.h b/chrome/browser/profiles/profile_manager.h +index b60df76d..7d02af7 100644 +--- a/chrome/browser/profiles/profile_manager.h ++++ b/chrome/browser/profiles/profile_manager.h +@@ -409,6 +409,10 @@ class ProfileManager : public content::NotificationObserver, + const base::FilePath& profile_dir); + #endif // !defined(OS_ANDROID) + ++ // Destroy after |profile_info_cache_| since Profile destruction may trigger ++ // some observers to unregister themselves. ++ base::ObserverList observers_; ++ + // Object to cache various information about profiles. Contains information + // about every profile which has been created for this instance of Chrome, + // if it has not been explicitly deleted. It must be destroyed after +@@ -450,8 +454,6 @@ class ProfileManager : public content::NotificationObserver, + // Controls whether to initialize some services. Only disabled for testing. + bool do_final_services_init_ = true; + +- base::ObserverList observers_; +- + // TODO(chrome/browser/profiles/OWNERS): Usage of this in profile_manager.cc + // should likely be turned into DCHECK_CURRENTLY_ON(BrowserThread::UI) for + // consistency with surrounding code in the same file but that wasn't trivial diff --git a/chromium-78-protobuf-export.patch b/chromium-78-protobuf-export.patch new file mode 100644 index 00000000..ddb9e80e --- /dev/null +++ b/chromium-78-protobuf-export.patch @@ -0,0 +1,13 @@ +diff --git a/third_party/protobuf/src/google/protobuf/repeated_field.h b/third_party/protobuf/src/google/protobuf/repeated_field.h +index b5b193c..4434854 100644 +--- a/third_party/protobuf/src/google/protobuf/repeated_field.h ++++ b/third_party/protobuf/src/google/protobuf/repeated_field.h +@@ -804,7 +804,7 @@ class StringTypeHandler { + // RepeatedPtrField is like RepeatedField, but used for repeated strings or + // Messages. + template +-class RepeatedPtrField final : private internal::RepeatedPtrFieldBase { ++class PROTOBUF_EXPORT RepeatedPtrField final : private internal::RepeatedPtrFieldBase { + public: + RepeatedPtrField(); + explicit RepeatedPtrField(Arena* arena); diff --git a/chromium-78-revert-noexcept-r1.patch b/chromium-78-revert-noexcept-r1.patch new file mode 100644 index 00000000..408d618b --- /dev/null +++ b/chromium-78-revert-noexcept-r1.patch @@ -0,0 +1,1471 @@ +From 37a95dd93e553888c00cf9443a5ec738ce658e65 Mon Sep 17 00:00:00 2001 +From: Zinovy Nis +Date: Mon, 16 Sep 2019 13:08:17 +0000 +Subject: [PATCH] Revert "[clang-tidy] add noexcept for move ctors and operator= in blink" + +This reverts commit 8f3eea10fe63a64ac67dc21542ebee6b896156a3. + +Reason for revert: code bloating + +Original change's description: +> [clang-tidy] add noexcept for move ctors and operator= in blink +> +> Bug: 994915 +> Change-Id: I2e1bcf286a2d2fa6613e18b5268098a0d258fb2e +> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1759163 +> Commit-Queue: Zinovy Nis +> Reviewed-by: Jeremy Roman +> Reviewed-by: Mike West +> Cr-Commit-Position: refs/heads/master@{#688676} + +TBR=jbroman@chromium.org,foolip@chromium.org,mkwst@chromium.org,zynis@yandex-team.ru + +# Not skipping CQ checks because original CL landed > 1 day ago. + +Bug: 994915 +Change-Id: I12b3ecc1186e27809082dc399c6d6864109ce307 +--- + +diff --git a/third_party/blink/common/indexeddb/indexeddb_key_path.cc b/third_party/blink/common/indexeddb/indexeddb_key_path.cc +index ec2b618..552d541 100644 +--- a/third_party/blink/common/indexeddb/indexeddb_key_path.cc ++++ b/third_party/blink/common/indexeddb/indexeddb_key_path.cc +@@ -18,12 +18,12 @@ + : type_(mojom::IDBKeyPathType::Array), array_(array) {} + + IndexedDBKeyPath::IndexedDBKeyPath(const IndexedDBKeyPath& other) = default; +-IndexedDBKeyPath::IndexedDBKeyPath(IndexedDBKeyPath&& other) noexcept = default; ++IndexedDBKeyPath::IndexedDBKeyPath(IndexedDBKeyPath&& other) = default; + IndexedDBKeyPath::~IndexedDBKeyPath() = default; + IndexedDBKeyPath& IndexedDBKeyPath::operator=(const IndexedDBKeyPath& other) = + default; +-IndexedDBKeyPath& IndexedDBKeyPath::operator=( +- IndexedDBKeyPath&& other) noexcept = default; ++IndexedDBKeyPath& IndexedDBKeyPath::operator=(IndexedDBKeyPath&& other) = ++ default; + + const std::vector& IndexedDBKeyPath::array() const { + DCHECK(type_ == blink::mojom::IDBKeyPathType::Array); +diff --git a/third_party/blink/common/indexeddb/indexeddb_metadata.cc b/third_party/blink/common/indexeddb/indexeddb_metadata.cc +index 50d5845..9349732 100644 +--- a/third_party/blink/common/indexeddb/indexeddb_metadata.cc ++++ b/third_party/blink/common/indexeddb/indexeddb_metadata.cc +@@ -23,15 +23,15 @@ + + IndexedDBIndexMetadata::IndexedDBIndexMetadata( + const IndexedDBIndexMetadata& other) = default; +-IndexedDBIndexMetadata::IndexedDBIndexMetadata( +- IndexedDBIndexMetadata&& other) noexcept = default; ++IndexedDBIndexMetadata::IndexedDBIndexMetadata(IndexedDBIndexMetadata&& other) = ++ default; + + IndexedDBIndexMetadata::~IndexedDBIndexMetadata() = default; + + IndexedDBIndexMetadata& IndexedDBIndexMetadata::operator=( + const IndexedDBIndexMetadata& other) = default; + IndexedDBIndexMetadata& IndexedDBIndexMetadata::operator=( +- IndexedDBIndexMetadata&& other) noexcept = default; ++ IndexedDBIndexMetadata&& other) = default; + + bool IndexedDBIndexMetadata::operator==( + const IndexedDBIndexMetadata& other) const { +@@ -56,14 +56,14 @@ + IndexedDBObjectStoreMetadata::IndexedDBObjectStoreMetadata( + const IndexedDBObjectStoreMetadata& other) = default; + IndexedDBObjectStoreMetadata::IndexedDBObjectStoreMetadata( +- IndexedDBObjectStoreMetadata&& other) noexcept = default; ++ IndexedDBObjectStoreMetadata&& other) = default; + + IndexedDBObjectStoreMetadata::~IndexedDBObjectStoreMetadata() = default; + + IndexedDBObjectStoreMetadata& IndexedDBObjectStoreMetadata::operator=( + const IndexedDBObjectStoreMetadata& other) = default; + IndexedDBObjectStoreMetadata& IndexedDBObjectStoreMetadata::operator=( +- IndexedDBObjectStoreMetadata&& other) noexcept = default; ++ IndexedDBObjectStoreMetadata&& other) = default; + + bool IndexedDBObjectStoreMetadata::operator==( + const IndexedDBObjectStoreMetadata& other) const { +@@ -87,14 +87,14 @@ + IndexedDBDatabaseMetadata::IndexedDBDatabaseMetadata( + const IndexedDBDatabaseMetadata& other) = default; + IndexedDBDatabaseMetadata::IndexedDBDatabaseMetadata( +- IndexedDBDatabaseMetadata&& other) noexcept = default; ++ IndexedDBDatabaseMetadata&& other) = default; + + IndexedDBDatabaseMetadata::~IndexedDBDatabaseMetadata() = default; + + IndexedDBDatabaseMetadata& IndexedDBDatabaseMetadata::operator=( + const IndexedDBDatabaseMetadata& other) = default; + IndexedDBDatabaseMetadata& IndexedDBDatabaseMetadata::operator=( +- IndexedDBDatabaseMetadata&& other) noexcept = default; ++ IndexedDBDatabaseMetadata&& other) = default; + + bool IndexedDBDatabaseMetadata::operator==( + const IndexedDBDatabaseMetadata& other) const { +diff --git a/third_party/blink/common/mediastream/media_devices.cc b/third_party/blink/common/mediastream/media_devices.cc +index 93df201..3661b4b 100644 +--- a/third_party/blink/common/mediastream/media_devices.cc ++++ b/third_party/blink/common/mediastream/media_devices.cc +@@ -13,8 +13,7 @@ + WebMediaDeviceInfo::WebMediaDeviceInfo(const WebMediaDeviceInfo& other) = + default; + +-WebMediaDeviceInfo::WebMediaDeviceInfo(WebMediaDeviceInfo&& other) noexcept = +- default; ++WebMediaDeviceInfo::WebMediaDeviceInfo(WebMediaDeviceInfo&& other) = default; + + WebMediaDeviceInfo::WebMediaDeviceInfo(const std::string& device_id, + const std::string& label, +@@ -36,8 +35,8 @@ + WebMediaDeviceInfo& WebMediaDeviceInfo::operator=( + const WebMediaDeviceInfo& other) = default; + +-WebMediaDeviceInfo& WebMediaDeviceInfo::operator=( +- WebMediaDeviceInfo&& other) noexcept = default; ++WebMediaDeviceInfo& WebMediaDeviceInfo::operator=(WebMediaDeviceInfo&& other) = ++ default; + + bool operator==(const WebMediaDeviceInfo& first, + const WebMediaDeviceInfo& second) { +diff --git a/third_party/blink/common/messaging/cloneable_message.cc b/third_party/blink/common/messaging/cloneable_message.cc +index 2984fd1..5c3ee7e 100644 +--- a/third_party/blink/common/messaging/cloneable_message.cc ++++ b/third_party/blink/common/messaging/cloneable_message.cc +@@ -12,9 +12,8 @@ + namespace blink { + + CloneableMessage::CloneableMessage() = default; +-CloneableMessage::CloneableMessage(CloneableMessage&&) noexcept = default; +-CloneableMessage& CloneableMessage::operator=(CloneableMessage&&) noexcept = +- default; ++CloneableMessage::CloneableMessage(CloneableMessage&&) = default; ++CloneableMessage& CloneableMessage::operator=(CloneableMessage&&) = default; + CloneableMessage::~CloneableMessage() = default; + + CloneableMessage CloneableMessage::ShallowClone() const { +diff --git a/third_party/blink/common/messaging/transferable_message.cc b/third_party/blink/common/messaging/transferable_message.cc +index 07ac9bb..4a69d0a 100644 +--- a/third_party/blink/common/messaging/transferable_message.cc ++++ b/third_party/blink/common/messaging/transferable_message.cc +@@ -9,10 +9,9 @@ + namespace blink { + + TransferableMessage::TransferableMessage() = default; +-TransferableMessage::TransferableMessage(TransferableMessage&&) noexcept = ++TransferableMessage::TransferableMessage(TransferableMessage&&) = default; ++TransferableMessage& TransferableMessage::operator=(TransferableMessage&&) = + default; +-TransferableMessage& TransferableMessage::operator=( +- TransferableMessage&&) noexcept = default; + TransferableMessage::~TransferableMessage() = default; + + } // namespace blink +diff --git a/third_party/blink/public/common/indexeddb/indexeddb_key_path.h b/third_party/blink/public/common/indexeddb/indexeddb_key_path.h +index 8ebe10c..9f5422c 100644 +--- a/third_party/blink/public/common/indexeddb/indexeddb_key_path.h ++++ b/third_party/blink/public/common/indexeddb/indexeddb_key_path.h +@@ -22,10 +22,10 @@ + explicit IndexedDBKeyPath(const base::string16&); + explicit IndexedDBKeyPath(const std::vector&); + IndexedDBKeyPath(const IndexedDBKeyPath& other); +- IndexedDBKeyPath(IndexedDBKeyPath&& other) noexcept; ++ IndexedDBKeyPath(IndexedDBKeyPath&& other); + ~IndexedDBKeyPath(); + IndexedDBKeyPath& operator=(const IndexedDBKeyPath& other); +- IndexedDBKeyPath& operator=(IndexedDBKeyPath&& other) noexcept; ++ IndexedDBKeyPath& operator=(IndexedDBKeyPath&& other); + + bool IsNull() const { return type_ == blink::mojom::IDBKeyPathType::Null; } + bool operator==(const IndexedDBKeyPath& other) const; +diff --git a/third_party/blink/public/common/indexeddb/indexeddb_metadata.h b/third_party/blink/public/common/indexeddb/indexeddb_metadata.h +index 15663f6..7bb37c9 100644 +--- a/third_party/blink/public/common/indexeddb/indexeddb_metadata.h ++++ b/third_party/blink/public/common/indexeddb/indexeddb_metadata.h +@@ -26,10 +26,10 @@ + bool unique, + bool multi_entry); + IndexedDBIndexMetadata(const IndexedDBIndexMetadata& other); +- IndexedDBIndexMetadata(IndexedDBIndexMetadata&& other) noexcept; ++ IndexedDBIndexMetadata(IndexedDBIndexMetadata&& other); + ~IndexedDBIndexMetadata(); + IndexedDBIndexMetadata& operator=(const IndexedDBIndexMetadata& other); +- IndexedDBIndexMetadata& operator=(IndexedDBIndexMetadata&& other) noexcept; ++ IndexedDBIndexMetadata& operator=(IndexedDBIndexMetadata&& other); + bool operator==(const IndexedDBIndexMetadata& other) const; + + base::string16 name; +@@ -50,12 +50,11 @@ + bool auto_increment, + int64_t max_index_id); + IndexedDBObjectStoreMetadata(const IndexedDBObjectStoreMetadata& other); +- IndexedDBObjectStoreMetadata(IndexedDBObjectStoreMetadata&& other) noexcept; ++ IndexedDBObjectStoreMetadata(IndexedDBObjectStoreMetadata&& other); + ~IndexedDBObjectStoreMetadata(); + IndexedDBObjectStoreMetadata& operator=( + const IndexedDBObjectStoreMetadata& other); +- IndexedDBObjectStoreMetadata& operator=( +- IndexedDBObjectStoreMetadata&& other) noexcept; ++ IndexedDBObjectStoreMetadata& operator=(IndexedDBObjectStoreMetadata&& other); + bool operator==(const IndexedDBObjectStoreMetadata& other) const; + + base::string16 name; +@@ -77,11 +76,10 @@ + int64_t version, + int64_t max_object_store_id); + IndexedDBDatabaseMetadata(const IndexedDBDatabaseMetadata& other); +- IndexedDBDatabaseMetadata(IndexedDBDatabaseMetadata&& other) noexcept; ++ IndexedDBDatabaseMetadata(IndexedDBDatabaseMetadata&& other); + ~IndexedDBDatabaseMetadata(); + IndexedDBDatabaseMetadata& operator=(const IndexedDBDatabaseMetadata& other); +- IndexedDBDatabaseMetadata& operator=( +- IndexedDBDatabaseMetadata&& other) noexcept; ++ IndexedDBDatabaseMetadata& operator=(IndexedDBDatabaseMetadata&& other); + bool operator==(const IndexedDBDatabaseMetadata& other) const; + + base::string16 name; +diff --git a/third_party/blink/public/common/mediastream/media_devices.h b/third_party/blink/public/common/mediastream/media_devices.h +index 0d63e575..d87affe 100644 +--- a/third_party/blink/public/common/mediastream/media_devices.h ++++ b/third_party/blink/public/common/mediastream/media_devices.h +@@ -27,7 +27,7 @@ + struct BLINK_COMMON_EXPORT WebMediaDeviceInfo { + WebMediaDeviceInfo(); + WebMediaDeviceInfo(const WebMediaDeviceInfo& other); +- WebMediaDeviceInfo(WebMediaDeviceInfo&& other) noexcept; ++ WebMediaDeviceInfo(WebMediaDeviceInfo&& other); + WebMediaDeviceInfo( + const std::string& device_id, + const std::string& label, +@@ -37,7 +37,7 @@ + const media::VideoCaptureDeviceDescriptor& descriptor); + ~WebMediaDeviceInfo(); + WebMediaDeviceInfo& operator=(const WebMediaDeviceInfo& other); +- WebMediaDeviceInfo& operator=(WebMediaDeviceInfo&& other) noexcept; ++ WebMediaDeviceInfo& operator=(WebMediaDeviceInfo&& other); + + std::string device_id; + std::string label; +diff --git a/third_party/blink/public/common/messaging/cloneable_message.h b/third_party/blink/public/common/messaging/cloneable_message.h +index de9952d..8dbd910 100644 +--- a/third_party/blink/public/common/messaging/cloneable_message.h ++++ b/third_party/blink/public/common/messaging/cloneable_message.h +@@ -21,8 +21,8 @@ + // This type can be serialized as a blink::mojom::CloneableMessage struct. + struct BLINK_COMMON_EXPORT CloneableMessage { + CloneableMessage(); +- CloneableMessage(CloneableMessage&&) noexcept; +- CloneableMessage& operator=(CloneableMessage&&) noexcept; ++ CloneableMessage(CloneableMessage&&); ++ CloneableMessage& operator=(CloneableMessage&&); + ~CloneableMessage(); + + // Returns a shallow clone of this message. |encoded_message| in the clone +diff --git a/third_party/blink/public/common/messaging/transferable_message.h b/third_party/blink/public/common/messaging/transferable_message.h +index 5eef63c..2d87363 100644 +--- a/third_party/blink/public/common/messaging/transferable_message.h ++++ b/third_party/blink/public/common/messaging/transferable_message.h +@@ -22,8 +22,8 @@ + // type can be serialized as a blink::mojom::TransferableMessage struct. + struct BLINK_COMMON_EXPORT TransferableMessage : public CloneableMessage { + TransferableMessage(); +- TransferableMessage(TransferableMessage&&) noexcept; +- TransferableMessage& operator=(TransferableMessage&&) noexcept; ++ TransferableMessage(TransferableMessage&&); ++ TransferableMessage& operator=(TransferableMessage&&); + ~TransferableMessage(); + + // Any ports being transferred as part of this message. +diff --git a/third_party/blink/public/platform/scheduler/web_scoped_virtual_time_pauser.h b/third_party/blink/public/platform/scheduler/web_scoped_virtual_time_pauser.h +index 75f3ae16..81edd69 100644 +--- a/third_party/blink/public/platform/scheduler/web_scoped_virtual_time_pauser.h ++++ b/third_party/blink/public/platform/scheduler/web_scoped_virtual_time_pauser.h +@@ -42,9 +42,8 @@ + WebScopedVirtualTimePauser(); + ~WebScopedVirtualTimePauser(); + +- WebScopedVirtualTimePauser(WebScopedVirtualTimePauser&& other) noexcept; +- WebScopedVirtualTimePauser& operator=( +- WebScopedVirtualTimePauser&& other) noexcept; ++ WebScopedVirtualTimePauser(WebScopedVirtualTimePauser&& other); ++ WebScopedVirtualTimePauser& operator=(WebScopedVirtualTimePauser&& other); + + WebScopedVirtualTimePauser(const WebScopedVirtualTimePauser&) = delete; + WebScopedVirtualTimePauser& operator=(const WebScopedVirtualTimePauser&) = +diff --git a/third_party/blink/public/platform/web_string.h b/third_party/blink/public/platform/web_string.h +index e4fda4f..ffd1da0 100644 +--- a/third_party/blink/public/platform/web_string.h ++++ b/third_party/blink/public/platform/web_string.h +@@ -102,10 +102,10 @@ + BLINK_PLATFORM_EXPORT WebString(const WebUChar* data, size_t len); + + BLINK_PLATFORM_EXPORT WebString(const WebString&); +- BLINK_PLATFORM_EXPORT WebString(WebString&&) noexcept; ++ BLINK_PLATFORM_EXPORT WebString(WebString&&); + + BLINK_PLATFORM_EXPORT WebString& operator=(const WebString&); +- BLINK_PLATFORM_EXPORT WebString& operator=(WebString&&) noexcept; ++ BLINK_PLATFORM_EXPORT WebString& operator=(WebString&&); + + BLINK_PLATFORM_EXPORT void Reset(); + +diff --git a/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util.h b/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util.h +index 99f47f5..8451b86 100644 +--- a/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util.h ++++ b/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util.h +@@ -73,8 +73,8 @@ + + VideoCaptureSettings(const VideoCaptureSettings& other); + VideoCaptureSettings& operator=(const VideoCaptureSettings& other); +- VideoCaptureSettings(VideoCaptureSettings&& other) noexcept; +- VideoCaptureSettings& operator=(VideoCaptureSettings&& other) noexcept; ++ VideoCaptureSettings(VideoCaptureSettings&& other); ++ VideoCaptureSettings& operator=(VideoCaptureSettings&& other); + ~VideoCaptureSettings(); + + bool HasValue() const { return !failed_constraint_name_; } +@@ -193,8 +193,8 @@ + const AudioProcessingProperties& audio_processing_properties); + AudioCaptureSettings(const AudioCaptureSettings& other); + AudioCaptureSettings& operator=(const AudioCaptureSettings& other); +- AudioCaptureSettings(AudioCaptureSettings&& other) noexcept; +- AudioCaptureSettings& operator=(AudioCaptureSettings&& other) noexcept; ++ AudioCaptureSettings(AudioCaptureSettings&& other); ++ AudioCaptureSettings& operator=(AudioCaptureSettings&& other); + + bool HasValue() const { return !failed_constraint_name_; } + +diff --git a/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util_sets.h b/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util_sets.h +index 199bdeb..c89e6e9 100644 +--- a/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util_sets.h ++++ b/third_party/blink/public/web/modules/mediastream/media_stream_constraints_util_sets.h +@@ -159,8 +159,8 @@ + + DiscreteSet(const DiscreteSet& other) = default; + DiscreteSet& operator=(const DiscreteSet& other) = default; +- DiscreteSet(DiscreteSet&& other) noexcept = default; +- DiscreteSet& operator=(DiscreteSet&& other) noexcept = default; ++ DiscreteSet(DiscreteSet&& other) = default; ++ DiscreteSet& operator=(DiscreteSet&& other) = default; + ~DiscreteSet() = default; + + bool Contains(const T& value) const { +diff --git a/third_party/blink/public/web/modules/mediastream/media_stream_video_source.h b/third_party/blink/public/web/modules/mediastream/media_stream_video_source.h +index 5e50d1b..ed5967f 100644 +--- a/third_party/blink/public/web/modules/mediastream/media_stream_video_source.h ++++ b/third_party/blink/public/web/modules/mediastream/media_stream_video_source.h +@@ -285,8 +285,8 @@ + const VideoTrackFormatCallback& format_callback, + std::unique_ptr adapter_settings, + const ConstraintsCallback& callback); +- PendingTrackInfo(PendingTrackInfo&& other) noexcept; +- PendingTrackInfo& operator=(PendingTrackInfo&& other) noexcept; ++ PendingTrackInfo(PendingTrackInfo&& other); ++ PendingTrackInfo& operator=(PendingTrackInfo&& other); + ~PendingTrackInfo(); + + MediaStreamVideoTrack* track; +diff --git a/third_party/blink/renderer/core/animation/interpolation_value.h b/third_party/blink/renderer/core/animation/interpolation_value.h +index 75c5d35..17ccf02 100644 +--- a/third_party/blink/renderer/core/animation/interpolation_value.h ++++ b/third_party/blink/renderer/core/animation/interpolation_value.h +@@ -27,11 +27,11 @@ + + InterpolationValue(std::nullptr_t) {} + +- InterpolationValue(InterpolationValue&& other) noexcept ++ InterpolationValue(InterpolationValue&& other) + : interpolable_value(std::move(other.interpolable_value)), + non_interpolable_value(std::move(other.non_interpolable_value)) {} + +- void operator=(InterpolationValue&& other) noexcept { ++ void operator=(InterpolationValue&& other) { + interpolable_value = std::move(other.interpolable_value); + non_interpolable_value = std::move(other.non_interpolable_value); + } +diff --git a/third_party/blink/renderer/core/animation/pairwise_interpolation_value.h b/third_party/blink/renderer/core/animation/pairwise_interpolation_value.h +index 39e6c57..87bb431 100644 +--- a/third_party/blink/renderer/core/animation/pairwise_interpolation_value.h ++++ b/third_party/blink/renderer/core/animation/pairwise_interpolation_value.h +@@ -28,7 +28,7 @@ + + PairwiseInterpolationValue(std::nullptr_t) {} + +- PairwiseInterpolationValue(PairwiseInterpolationValue&& other) noexcept ++ PairwiseInterpolationValue(PairwiseInterpolationValue&& other) + : start_interpolable_value(std::move(other.start_interpolable_value)), + end_interpolable_value(std::move(other.end_interpolable_value)), + non_interpolable_value(std::move(other.non_interpolable_value)) {} +diff --git a/third_party/blink/renderer/core/css/css_selector_list.h b/third_party/blink/renderer/core/css/css_selector_list.h +index 4d38b09..51f354b 100644 +--- a/third_party/blink/renderer/core/css/css_selector_list.h ++++ b/third_party/blink/renderer/core/css/css_selector_list.h +@@ -67,8 +67,7 @@ + public: + CSSSelectorList() : selector_array_(nullptr) {} + +- CSSSelectorList(CSSSelectorList&& o) noexcept +- : selector_array_(o.selector_array_) { ++ CSSSelectorList(CSSSelectorList&& o) : selector_array_(o.selector_array_) { + o.selector_array_ = nullptr; + } + +@@ -82,7 +81,7 @@ + bool HasPseudoWhere() const; + bool RequiresExpansion() const; + +- CSSSelectorList& operator=(CSSSelectorList&& o) noexcept { ++ CSSSelectorList& operator=(CSSSelectorList&& o) { + DCHECK(this != &o); + DeleteSelectorsIfNeeded(); + selector_array_ = o.selector_array_; +diff --git a/third_party/blink/renderer/core/display_lock/display_lock_context.cc b/third_party/blink/renderer/core/display_lock/display_lock_context.cc +index 0e6b6cb..79f281a 100644 +--- a/third_party/blink/renderer/core/display_lock/display_lock_context.cc ++++ b/third_party/blink/renderer/core/display_lock/display_lock_context.cc +@@ -1033,7 +1033,7 @@ + : context_(context) {} + + DisplayLockContext::ScopedForcedUpdate::ScopedForcedUpdate( +- ScopedForcedUpdate&& other) noexcept ++ ScopedForcedUpdate&& other) + : context_(other.context_) { + other.context_ = nullptr; + } +diff --git a/third_party/blink/renderer/core/display_lock/display_lock_context.h b/third_party/blink/renderer/core/display_lock/display_lock_context.h +index 1a38b2af..f890b432 100644 +--- a/third_party/blink/renderer/core/display_lock/display_lock_context.h ++++ b/third_party/blink/renderer/core/display_lock/display_lock_context.h +@@ -76,7 +76,7 @@ + DISALLOW_NEW(); + + public: +- ScopedForcedUpdate(ScopedForcedUpdate&&) noexcept; ++ ScopedForcedUpdate(ScopedForcedUpdate&&); + ~ScopedForcedUpdate(); + + private: +diff --git a/third_party/blink/renderer/core/editing/layout_selection.cc b/third_party/blink/renderer/core/editing/layout_selection.cc +index 00040d2..73cfe0f 100644 +--- a/third_party/blink/renderer/core/editing/layout_selection.cc ++++ b/third_party/blink/renderer/core/editing/layout_selection.cc +@@ -178,7 +178,7 @@ + public: + OldSelectedNodes() + : paint_range(MakeGarbageCollected()) {} +- OldSelectedNodes(OldSelectedNodes&& other) noexcept { ++ OldSelectedNodes(OldSelectedNodes&& other) { + paint_range = other.paint_range; + selected_map = std::move(other.selected_map); + } +@@ -205,8 +205,7 @@ + HeapHashSet>&& passed_selected_objects) + : paint_range(passed_paint_range), + selected_objects(std::move(passed_selected_objects)) {} +- NewPaintRangeAndSelectedNodes( +- NewPaintRangeAndSelectedNodes&& other) noexcept { ++ NewPaintRangeAndSelectedNodes(NewPaintRangeAndSelectedNodes&& other) { + paint_range = other.paint_range; + selected_objects = std::move(other.selected_objects); + } +diff --git a/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.cc b/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.cc +index f0ac3c4..81f47ab 100644 +--- a/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.cc ++++ b/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.cc +@@ -24,7 +24,7 @@ + start_time_(clock_->NowTicks()) {} + + LocalFrameUkmAggregator::ScopedUkmHierarchicalTimer::ScopedUkmHierarchicalTimer( +- ScopedUkmHierarchicalTimer&& other) noexcept ++ ScopedUkmHierarchicalTimer&& other) + : aggregator_(other.aggregator_), + metric_index_(other.metric_index_), + clock_(other.clock_), +diff --git a/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.h b/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.h +index 44c3f87..dc06091 100644 +--- a/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.h ++++ b/third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.h +@@ -195,7 +195,7 @@ + STACK_ALLOCATED(); + + public: +- ScopedUkmHierarchicalTimer(ScopedUkmHierarchicalTimer&&) noexcept; ++ ScopedUkmHierarchicalTimer(ScopedUkmHierarchicalTimer&&); + ~ScopedUkmHierarchicalTimer(); + + private: +diff --git a/third_party/blink/renderer/core/layout/ng/inline/ng_line_box_fragment_builder.h b/third_party/blink/renderer/core/layout/ng/inline/ng_line_box_fragment_builder.h +index 2af19ca..498e42e 100644 +--- a/third_party/blink/renderer/core/layout/ng/inline/ng_line_box_fragment_builder.h ++++ b/third_party/blink/renderer/core/layout/ng/inline/ng_line_box_fragment_builder.h +@@ -181,7 +181,7 @@ + + public: + ChildList() = default; +- void operator=(ChildList&& other) noexcept { ++ void operator=(ChildList&& other) { + children_ = std::move(other.children_); + } + +diff --git a/third_party/blink/renderer/core/layout/ng/ng_constraint_space.h b/third_party/blink/renderer/core/layout/ng/ng_constraint_space.h +index 8f77b90..833b0d2 100644 +--- a/third_party/blink/renderer/core/layout/ng/ng_constraint_space.h ++++ b/third_party/blink/renderer/core/layout/ng/ng_constraint_space.h +@@ -86,7 +86,7 @@ + else + bfc_offset_ = other.bfc_offset_; + } +- NGConstraintSpace(NGConstraintSpace&& other) noexcept ++ NGConstraintSpace(NGConstraintSpace&& other) + : available_size_(other.available_size_), + exclusion_space_(std::move(other.exclusion_space_)), + bitfields_(other.bitfields_) { +@@ -110,7 +110,7 @@ + bitfields_ = other.bitfields_; + return *this; + } +- NGConstraintSpace& operator=(NGConstraintSpace&& other) noexcept { ++ NGConstraintSpace& operator=(NGConstraintSpace&& other) { + available_size_ = other.available_size_; + if (HasRareData()) + delete rare_data_; +diff --git a/third_party/blink/renderer/core/messaging/blink_cloneable_message.cc b/third_party/blink/renderer/core/messaging/blink_cloneable_message.cc +index b6c8768..7423930 100644 +--- a/third_party/blink/renderer/core/messaging/blink_cloneable_message.cc ++++ b/third_party/blink/renderer/core/messaging/blink_cloneable_message.cc +@@ -9,9 +9,8 @@ + BlinkCloneableMessage::BlinkCloneableMessage() = default; + BlinkCloneableMessage::~BlinkCloneableMessage() = default; + +-BlinkCloneableMessage::BlinkCloneableMessage(BlinkCloneableMessage&&) noexcept = +- default; ++BlinkCloneableMessage::BlinkCloneableMessage(BlinkCloneableMessage&&) = default; + BlinkCloneableMessage& BlinkCloneableMessage::operator=( +- BlinkCloneableMessage&&) noexcept = default; ++ BlinkCloneableMessage&&) = default; + + } // namespace blink +diff --git a/third_party/blink/renderer/core/messaging/blink_cloneable_message.h b/third_party/blink/renderer/core/messaging/blink_cloneable_message.h +index 337b0f8..a51e888 100644 +--- a/third_party/blink/renderer/core/messaging/blink_cloneable_message.h ++++ b/third_party/blink/renderer/core/messaging/blink_cloneable_message.h +@@ -21,8 +21,8 @@ + BlinkCloneableMessage(); + ~BlinkCloneableMessage(); + +- BlinkCloneableMessage(BlinkCloneableMessage&&) noexcept; +- BlinkCloneableMessage& operator=(BlinkCloneableMessage&&) noexcept; ++ BlinkCloneableMessage(BlinkCloneableMessage&&); ++ BlinkCloneableMessage& operator=(BlinkCloneableMessage&&); + + scoped_refptr message; + v8_inspector::V8StackTraceId sender_stack_trace_id; +diff --git a/third_party/blink/renderer/core/messaging/blink_transferable_message.cc b/third_party/blink/renderer/core/messaging/blink_transferable_message.cc +index 909ddb0..b5cdfda 100644 +--- a/third_party/blink/renderer/core/messaging/blink_transferable_message.cc ++++ b/third_party/blink/renderer/core/messaging/blink_transferable_message.cc +@@ -16,10 +16,10 @@ + BlinkTransferableMessage::BlinkTransferableMessage() = default; + BlinkTransferableMessage::~BlinkTransferableMessage() = default; + +-BlinkTransferableMessage::BlinkTransferableMessage( +- BlinkTransferableMessage&&) noexcept = default; ++BlinkTransferableMessage::BlinkTransferableMessage(BlinkTransferableMessage&&) = ++ default; + BlinkTransferableMessage& BlinkTransferableMessage::operator=( +- BlinkTransferableMessage&&) noexcept = default; ++ BlinkTransferableMessage&&) = default; + + scoped_refptr ToStaticBitmapImage( + const SkBitmap& sk_bitmap) { +diff --git a/third_party/blink/renderer/core/messaging/blink_transferable_message.h b/third_party/blink/renderer/core/messaging/blink_transferable_message.h +index edf4fab..3957bed 100644 +--- a/third_party/blink/renderer/core/messaging/blink_transferable_message.h ++++ b/third_party/blink/renderer/core/messaging/blink_transferable_message.h +@@ -24,8 +24,8 @@ + BlinkTransferableMessage(); + ~BlinkTransferableMessage(); + +- BlinkTransferableMessage(BlinkTransferableMessage&&) noexcept; +- BlinkTransferableMessage& operator=(BlinkTransferableMessage&&) noexcept; ++ BlinkTransferableMessage(BlinkTransferableMessage&&); ++ BlinkTransferableMessage& operator=(BlinkTransferableMessage&&); + + Vector ports; + +diff --git a/third_party/blink/renderer/modules/imagecapture/image_capture_frame_grabber.h b/third_party/blink/renderer/modules/imagecapture/image_capture_frame_grabber.h +index 85b46e1..f050a85 100644 +--- a/third_party/blink/renderer/modules/imagecapture/image_capture_frame_grabber.h ++++ b/third_party/blink/renderer/modules/imagecapture/image_capture_frame_grabber.h +@@ -92,10 +92,10 @@ + std::move(destruction_callback_).Run(std::move(callbacks_)); + } + +- ScopedWebCallbacks(ScopedWebCallbacks&& other) noexcept = default; ++ ScopedWebCallbacks(ScopedWebCallbacks&& other) = default; + ScopedWebCallbacks(const ScopedWebCallbacks& other) = delete; + +- ScopedWebCallbacks& operator=(ScopedWebCallbacks&& other) noexcept = default; ++ ScopedWebCallbacks& operator=(ScopedWebCallbacks&& other) = default; + ScopedWebCallbacks& operator=(const ScopedWebCallbacks& other) = delete; + + std::unique_ptr PassCallbacks() { +diff --git a/third_party/blink/renderer/modules/indexeddb/idb_request.h b/third_party/blink/renderer/modules/indexeddb/idb_request.h +index f85b864..d3f1132 100644 +--- a/third_party/blink/renderer/modules/indexeddb/idb_request.h ++++ b/third_party/blink/renderer/modules/indexeddb/idb_request.h +@@ -110,13 +110,13 @@ + ~AsyncTraceState(); + + // Used to transfer the trace end event state to an IDBRequest. +- AsyncTraceState(AsyncTraceState&& other) noexcept { ++ AsyncTraceState(AsyncTraceState&& other) { + DCHECK(IsEmpty()); + this->trace_event_name_ = other.trace_event_name_; + this->id_ = other.id_; + other.trace_event_name_ = nullptr; + } +- AsyncTraceState& operator=(AsyncTraceState&& rhs) noexcept { ++ AsyncTraceState& operator=(AsyncTraceState&& rhs) { + DCHECK(IsEmpty()); + this->trace_event_name_ = rhs.trace_event_name_; + this->id_ = rhs.id_; +diff --git a/third_party/blink/renderer/modules/indexeddb/idb_request_test.cc b/third_party/blink/renderer/modules/indexeddb/idb_request_test.cc +index 84de726..2d3d4de5 100644 +--- a/third_party/blink/renderer/modules/indexeddb/idb_request_test.cc ++++ b/third_party/blink/renderer/modules/indexeddb/idb_request_test.cc +@@ -434,10 +434,9 @@ + class AsyncTraceStateForTesting : public IDBRequest::AsyncTraceState { + public: + AsyncTraceStateForTesting() : IDBRequest::AsyncTraceState() {} +- AsyncTraceStateForTesting(AsyncTraceStateForTesting&& other) noexcept ++ AsyncTraceStateForTesting(AsyncTraceStateForTesting&& other) + : IDBRequest::AsyncTraceState(std::move(other)) {} +- AsyncTraceStateForTesting& operator=( +- AsyncTraceStateForTesting&& rhs) noexcept { ++ AsyncTraceStateForTesting& operator=(AsyncTraceStateForTesting&& rhs) { + AsyncTraceState::operator=(std::move(rhs)); + return *this; + } +diff --git a/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util.cc b/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util.cc +index 24499bd..3bf00e9 100644 +--- a/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util.cc ++++ b/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util.cc +@@ -134,13 +134,13 @@ + + VideoCaptureSettings::VideoCaptureSettings(const VideoCaptureSettings& other) = + default; +-VideoCaptureSettings::VideoCaptureSettings( +- VideoCaptureSettings&& other) noexcept = default; ++VideoCaptureSettings::VideoCaptureSettings(VideoCaptureSettings&& other) = ++ default; + VideoCaptureSettings::~VideoCaptureSettings() = default; + VideoCaptureSettings& VideoCaptureSettings::operator=( + const VideoCaptureSettings& other) = default; + VideoCaptureSettings& VideoCaptureSettings::operator=( +- VideoCaptureSettings&& other) noexcept = default; ++ VideoCaptureSettings&& other) = default; + + AudioCaptureSettings::AudioCaptureSettings() : AudioCaptureSettings("") {} + +@@ -166,10 +166,10 @@ + default; + AudioCaptureSettings& AudioCaptureSettings::operator=( + const AudioCaptureSettings& other) = default; +-AudioCaptureSettings::AudioCaptureSettings( +- AudioCaptureSettings&& other) noexcept = default; ++AudioCaptureSettings::AudioCaptureSettings(AudioCaptureSettings&& other) = ++ default; + AudioCaptureSettings& AudioCaptureSettings::operator=( +- AudioCaptureSettings&& other) noexcept = default; ++ AudioCaptureSettings&& other) = default; + + bool GetConstraintValueAsBoolean( + const WebMediaConstraints& constraints, +diff --git a/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.cc b/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.cc +index 96992217..67c8bab 100644 +--- a/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.cc ++++ b/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.cc +@@ -529,9 +529,9 @@ + facing_mode(facing_mode) {} + + VideoInputDeviceCapabilities::VideoInputDeviceCapabilities( +- VideoInputDeviceCapabilities&& other) noexcept = default; ++ VideoInputDeviceCapabilities&& other) = default; + VideoInputDeviceCapabilities& VideoInputDeviceCapabilities::operator=( +- VideoInputDeviceCapabilities&& other) noexcept = default; ++ VideoInputDeviceCapabilities&& other) = default; + + VideoInputDeviceCapabilities::~VideoInputDeviceCapabilities() = default; + +@@ -557,10 +557,10 @@ + + VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities() = default; + VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities( +- VideoDeviceCaptureCapabilities&& other) noexcept = default; ++ VideoDeviceCaptureCapabilities&& other) = default; + VideoDeviceCaptureCapabilities::~VideoDeviceCaptureCapabilities() = default; + VideoDeviceCaptureCapabilities& VideoDeviceCaptureCapabilities::operator=( +- VideoDeviceCaptureCapabilities&& other) noexcept = default; ++ VideoDeviceCaptureCapabilities&& other) = default; + + VideoCaptureSettings SelectSettingsVideoDeviceCapture( + const VideoDeviceCaptureCapabilities& capabilities, +diff --git a/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.h b/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.h +index 66ae103..94d8ed9 100644 +--- a/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.h ++++ b/third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_device.h +@@ -34,9 +34,8 @@ + Vector formats, + media::VideoFacingMode facing_mode); + VideoInputDeviceCapabilities(); +- VideoInputDeviceCapabilities(VideoInputDeviceCapabilities&& other) noexcept; +- VideoInputDeviceCapabilities& operator=( +- VideoInputDeviceCapabilities&& other) noexcept; ++ VideoInputDeviceCapabilities(VideoInputDeviceCapabilities&& other); ++ VideoInputDeviceCapabilities& operator=(VideoInputDeviceCapabilities&& other); + ~VideoInputDeviceCapabilities(); + + String device_id; +@@ -47,11 +46,10 @@ + + struct MODULES_EXPORT VideoDeviceCaptureCapabilities { + VideoDeviceCaptureCapabilities(); +- VideoDeviceCaptureCapabilities( +- VideoDeviceCaptureCapabilities&& other) noexcept; ++ VideoDeviceCaptureCapabilities(VideoDeviceCaptureCapabilities&& other); + ~VideoDeviceCaptureCapabilities(); + VideoDeviceCaptureCapabilities& operator=( +- VideoDeviceCaptureCapabilities&& other) noexcept; ++ VideoDeviceCaptureCapabilities&& other); + + // Each capabilities field is independent of each other. + // TODO(crbug.com/704136): Replace VideoInputDeviceCapabilities in the +diff --git a/third_party/blink/renderer/modules/mediastream/media_stream_video_source.cc b/third_party/blink/renderer/modules/mediastream/media_stream_video_source.cc +index 7651e47..99759c1 100644 +--- a/third_party/blink/renderer/modules/mediastream/media_stream_video_source.cc ++++ b/third_party/blink/renderer/modules/mediastream/media_stream_video_source.cc +@@ -461,10 +461,10 @@ + callback(callback) {} + + MediaStreamVideoSource::PendingTrackInfo::PendingTrackInfo( +- PendingTrackInfo&& other) noexcept = default; ++ PendingTrackInfo&& other) = default; + MediaStreamVideoSource::PendingTrackInfo& + MediaStreamVideoSource::PendingTrackInfo::operator=( +- MediaStreamVideoSource::PendingTrackInfo&& other) noexcept = default; ++ MediaStreamVideoSource::PendingTrackInfo&& other) = default; + + MediaStreamVideoSource::PendingTrackInfo::~PendingTrackInfo() {} + +diff --git a/third_party/blink/renderer/platform/bindings/dom_data_store.h b/third_party/blink/renderer/platform/bindings/dom_data_store.h +index d660b67..0660dd18 100644 +--- a/third_party/blink/renderer/platform/bindings/dom_data_store.h ++++ b/third_party/blink/renderer/platform/bindings/dom_data_store.h +@@ -230,12 +230,11 @@ + : TraceWrapperV8Reference(isolate, handle) {} + + // Move support without write barrier. +- DOMWorldWrapperReference(DOMWorldWrapperReference&& other) noexcept ++ DOMWorldWrapperReference(DOMWorldWrapperReference&& other) + : TraceWrapperV8Reference() { + handle_ = std::move(other.handle_); + } +- DOMWorldWrapperReference& operator=( +- DOMWorldWrapperReference&& rhs) noexcept { ++ DOMWorldWrapperReference& operator=(DOMWorldWrapperReference&& rhs) { + handle_ = std::move(rhs.handle_); + return *this; + } +diff --git a/third_party/blink/renderer/platform/exported/web_string.cc b/third_party/blink/renderer/platform/exported/web_string.cc +index 71d4c07..fbe4828 100644 +--- a/third_party/blink/renderer/platform/exported/web_string.cc ++++ b/third_party/blink/renderer/platform/exported/web_string.cc +@@ -51,9 +51,9 @@ + WebString::~WebString() = default; + WebString::WebString() = default; + WebString::WebString(const WebString&) = default; +-WebString::WebString(WebString&&) noexcept = default; ++WebString::WebString(WebString&&) = default; + WebString& WebString::operator=(const WebString&) = default; +-WebString& WebString::operator=(WebString&&) noexcept = default; ++WebString& WebString::operator=(WebString&&) = default; + + WebString::WebString(const WebUChar* data, size_t len) + : impl_(StringImpl::Create8BitIfPossible(data, len)) {} +diff --git a/third_party/blink/renderer/platform/graphics/contiguous_container.cc b/third_party/blink/renderer/platform/graphics/contiguous_container.cc +index fd01c00..19cb6f2 100644 +--- a/third_party/blink/renderer/platform/graphics/contiguous_container.cc ++++ b/third_party/blink/renderer/platform/graphics/contiguous_container.cc +@@ -69,7 +69,7 @@ + : end_index_(0), max_object_size_(max_object_size) {} + + ContiguousContainerBase::ContiguousContainerBase( +- ContiguousContainerBase&& source) noexcept ++ ContiguousContainerBase&& source) + : ContiguousContainerBase(source.max_object_size_) { + Swap(source); + } +@@ -77,7 +77,7 @@ + ContiguousContainerBase::~ContiguousContainerBase() = default; + + ContiguousContainerBase& ContiguousContainerBase::operator=( +- ContiguousContainerBase&& source) noexcept { ++ ContiguousContainerBase&& source) { + Swap(source); + return *this; + } +diff --git a/third_party/blink/renderer/platform/graphics/contiguous_container.h b/third_party/blink/renderer/platform/graphics/contiguous_container.h +index 867e59c..3eee558 100644 +--- a/third_party/blink/renderer/platform/graphics/contiguous_container.h ++++ b/third_party/blink/renderer/platform/graphics/contiguous_container.h +@@ -42,10 +42,10 @@ + + protected: + explicit ContiguousContainerBase(size_t max_object_size); +- ContiguousContainerBase(ContiguousContainerBase&&) noexcept; ++ ContiguousContainerBase(ContiguousContainerBase&&); + ~ContiguousContainerBase(); + +- ContiguousContainerBase& operator=(ContiguousContainerBase&&) noexcept; ++ ContiguousContainerBase& operator=(ContiguousContainerBase&&); + + size_t size() const { return elements_.size(); } + bool IsEmpty() const { return !size(); } +@@ -147,7 +147,7 @@ + WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType)); + } + +- ContiguousContainer(ContiguousContainer&& source) noexcept ++ ContiguousContainer(ContiguousContainer&& source) + : ContiguousContainerBase(std::move(source)) {} + + ~ContiguousContainer() { +@@ -157,7 +157,7 @@ + } + } + +- ContiguousContainer& operator=(ContiguousContainer&& source) noexcept { ++ ContiguousContainer& operator=(ContiguousContainer&& source) { + // Must clear in the derived class to ensure that element destructors + // care called. + Clear(); +diff --git a/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.cc b/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.cc +index ad10c54..4edbf7f 100644 +--- a/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.cc ++++ b/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.cc +@@ -247,9 +247,9 @@ + } + + ImageLayerBridge::RegisteredBitmap::RegisteredBitmap() = default; +-ImageLayerBridge::RegisteredBitmap::RegisteredBitmap( +- RegisteredBitmap&& other) noexcept = default; ++ImageLayerBridge::RegisteredBitmap::RegisteredBitmap(RegisteredBitmap&& other) = ++ default; + ImageLayerBridge::RegisteredBitmap& ImageLayerBridge::RegisteredBitmap:: +-operator=(RegisteredBitmap&& other) noexcept = default; ++operator=(RegisteredBitmap&& other) = default; + + } // namespace blink +diff --git a/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.h b/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.h +index bea81dfb..b6879f9 100644 +--- a/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.h ++++ b/third_party/blink/renderer/platform/graphics/gpu/image_layer_bridge.h +@@ -65,8 +65,8 @@ + // only with software compositing. + struct RegisteredBitmap { + RegisteredBitmap(); +- RegisteredBitmap(RegisteredBitmap&& other) noexcept; +- RegisteredBitmap& operator=(RegisteredBitmap&& other) noexcept; ++ RegisteredBitmap(RegisteredBitmap&& other); ++ RegisteredBitmap& operator=(RegisteredBitmap&& other); + + scoped_refptr bitmap; + cc::SharedBitmapIdRegistration registration; +diff --git a/third_party/blink/renderer/platform/graphics/paint/display_item_list.h b/third_party/blink/renderer/platform/graphics/paint/display_item_list.h +index cd3ed2f..9ee2571 100644 +--- a/third_party/blink/renderer/platform/graphics/paint/display_item_list.h ++++ b/third_party/blink/renderer/platform/graphics/paint/display_item_list.h +@@ -28,10 +28,10 @@ + public: + DisplayItemList(size_t initial_size_bytes) + : ContiguousContainer(kMaximumDisplayItemSize, initial_size_bytes) {} +- DisplayItemList(DisplayItemList&& source) noexcept ++ DisplayItemList(DisplayItemList&& source) + : ContiguousContainer(std::move(source)) {} + +- DisplayItemList& operator=(DisplayItemList&& source) noexcept { ++ DisplayItemList& operator=(DisplayItemList&& source) { + ContiguousContainer::operator=(std::move(source)); + return *this; + } +diff --git a/third_party/blink/renderer/platform/heap/heap_test.cc b/third_party/blink/renderer/platform/heap/heap_test.cc +index dad0ca0..e94cbc95 100644 +--- a/third_party/blink/renderer/platform/heap/heap_test.cc ++++ b/third_party/blink/renderer/platform/heap/heap_test.cc +@@ -145,7 +145,7 @@ + } + KeyWithCopyingMoveConstructor(const KeyWithCopyingMoveConstructor&) = default; + // The move constructor delegates to the copy constructor intentionally. +- KeyWithCopyingMoveConstructor(KeyWithCopyingMoveConstructor&& x) noexcept ++ KeyWithCopyingMoveConstructor(KeyWithCopyingMoveConstructor&& x) + : KeyWithCopyingMoveConstructor(x) {} + KeyWithCopyingMoveConstructor& operator=( + const KeyWithCopyingMoveConstructor&) = default; +diff --git a/third_party/blink/renderer/platform/image-decoders/segment_stream.cc b/third_party/blink/renderer/platform/image-decoders/segment_stream.cc +index 4024f9c..5a98701 100644 +--- a/third_party/blink/renderer/platform/image-decoders/segment_stream.cc ++++ b/third_party/blink/renderer/platform/image-decoders/segment_stream.cc +@@ -10,10 +10,10 @@ + + SegmentStream::SegmentStream() = default; + +-SegmentStream::SegmentStream(SegmentStream&& rhs) noexcept ++SegmentStream::SegmentStream(SegmentStream&& rhs) + : reader_(std::move(rhs.reader_)), position_(rhs.position_) {} + +-SegmentStream& SegmentStream::operator=(SegmentStream&& rhs) noexcept { ++SegmentStream& SegmentStream::operator=(SegmentStream&& rhs) { + reader_ = std::move(rhs.reader_); + position_ = rhs.position_; + +diff --git a/third_party/blink/renderer/platform/image-decoders/segment_stream.h b/third_party/blink/renderer/platform/image-decoders/segment_stream.h +index f49f551..fa1ccf2 100644 +--- a/third_party/blink/renderer/platform/image-decoders/segment_stream.h ++++ b/third_party/blink/renderer/platform/image-decoders/segment_stream.h +@@ -19,8 +19,8 @@ + SegmentStream(); + SegmentStream(const SegmentStream&) = delete; + SegmentStream& operator=(const SegmentStream&) = delete; +- SegmentStream(SegmentStream&&) noexcept; +- SegmentStream& operator=(SegmentStream&&) noexcept; ++ SegmentStream(SegmentStream&&); ++ SegmentStream& operator=(SegmentStream&&); + + ~SegmentStream() override; + +diff --git a/third_party/blink/renderer/platform/mojo/revocable_interface_ptr.h b/third_party/blink/renderer/platform/mojo/revocable_interface_ptr.h +index 555be28..34bad3f 100644 +--- a/third_party/blink/renderer/platform/mojo/revocable_interface_ptr.h ++++ b/third_party/blink/renderer/platform/mojo/revocable_interface_ptr.h +@@ -41,7 +41,7 @@ + RevocableInterfacePtr(std::nullptr_t) {} + + // Takes over the binding of another RevocableInterfacePtr. +- RevocableInterfacePtr(RevocableInterfacePtr&& other) noexcept { ++ RevocableInterfacePtr(RevocableInterfacePtr&& other) { + interface_ptr_ = std::move(other.interface_ptr_); + SetInvalidator(other.invalidator_.get()); + // Reset the other interface ptr to remove it as an observer of the +@@ -58,7 +58,7 @@ + + // Takes over the binding of another RevocableInterfacePtr, and closes any + // message pipe already bound to this pointer. +- RevocableInterfacePtr& operator=(RevocableInterfacePtr&& other) noexcept { ++ RevocableInterfacePtr& operator=(RevocableInterfacePtr&& other) { + reset(); + interface_ptr_ = std::move(other.interface_ptr_); + SetInvalidator(other.invalidator_.get()); +diff --git a/third_party/blink/renderer/platform/network/encoded_form_data.cc b/third_party/blink/renderer/platform/network/encoded_form_data.cc +index bc4ec14..1b660e6 100644 +--- a/third_party/blink/renderer/platform/network/encoded_form_data.cc ++++ b/third_party/blink/renderer/platform/network/encoded_form_data.cc +@@ -61,11 +61,10 @@ + : type_(kDataPipe), data_pipe_getter_(std::move(data_pipe_getter)) {} + + FormDataElement::FormDataElement(const FormDataElement&) = default; +-FormDataElement::FormDataElement(FormDataElement&&) noexcept = default; ++FormDataElement::FormDataElement(FormDataElement&&) = default; + FormDataElement::~FormDataElement() = default; + FormDataElement& FormDataElement::operator=(const FormDataElement&) = default; +-FormDataElement& FormDataElement::operator=(FormDataElement&&) noexcept = +- default; ++FormDataElement& FormDataElement::operator=(FormDataElement&&) = default; + + bool operator==(const FormDataElement& a, const FormDataElement& b) { + if (&a == &b) +diff --git a/third_party/blink/renderer/platform/network/encoded_form_data.h b/third_party/blink/renderer/platform/network/encoded_form_data.h +index 48f84c8..865f664 100644 +--- a/third_party/blink/renderer/platform/network/encoded_form_data.h ++++ b/third_party/blink/renderer/platform/network/encoded_form_data.h +@@ -61,12 +61,12 @@ + explicit FormDataElement(scoped_refptr); + + FormDataElement(const FormDataElement&); +- FormDataElement(FormDataElement&&) noexcept; ++ FormDataElement(FormDataElement&&); + + ~FormDataElement(); + + FormDataElement& operator=(const FormDataElement&); +- FormDataElement& operator=(FormDataElement&&) noexcept; ++ FormDataElement& operator=(FormDataElement&&); + + bool IsSafeToSendToAnotherThread() const; + +diff --git a/third_party/blink/renderer/platform/scheduler/common/frame_or_worker_scheduler.cc b/third_party/blink/renderer/platform/scheduler/common/frame_or_worker_scheduler.cc +index ebe99ff..e971856 100644 +--- a/third_party/blink/renderer/platform/scheduler/common/frame_or_worker_scheduler.cc ++++ b/third_party/blink/renderer/platform/scheduler/common/frame_or_worker_scheduler.cc +@@ -28,15 +28,14 @@ + } + + FrameOrWorkerScheduler::SchedulingAffectingFeatureHandle:: +- SchedulingAffectingFeatureHandle( +- SchedulingAffectingFeatureHandle&& other) noexcept ++ SchedulingAffectingFeatureHandle(SchedulingAffectingFeatureHandle&& other) + : feature_(other.feature_), scheduler_(std::move(other.scheduler_)) { + other.scheduler_ = nullptr; + } + + FrameOrWorkerScheduler::SchedulingAffectingFeatureHandle& + FrameOrWorkerScheduler::SchedulingAffectingFeatureHandle::operator=( +- SchedulingAffectingFeatureHandle&& other) noexcept { ++ SchedulingAffectingFeatureHandle&& other) { + feature_ = other.feature_; + policy_ = std::move(other.policy_); + scheduler_ = std::move(other.scheduler_); +diff --git a/third_party/blink/renderer/platform/scheduler/common/post_cancellable_task.cc b/third_party/blink/renderer/platform/scheduler/common/post_cancellable_task.cc +index 2c84d70..fad56ee1 100644 +--- a/third_party/blink/renderer/platform/scheduler/common/post_cancellable_task.cc ++++ b/third_party/blink/renderer/platform/scheduler/common/post_cancellable_task.cc +@@ -103,9 +103,9 @@ + Cancel(); + } + +-TaskHandle::TaskHandle(TaskHandle&&) noexcept = default; ++TaskHandle::TaskHandle(TaskHandle&&) = default; + +-TaskHandle& TaskHandle::operator=(TaskHandle&& other) noexcept { ++TaskHandle& TaskHandle::operator=(TaskHandle&& other) { + TaskHandle tmp(std::move(other)); + runner_.swap(tmp.runner_); + return *this; +diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/web_scoped_virtual_time_pauser.cc b/third_party/blink/renderer/platform/scheduler/main_thread/web_scoped_virtual_time_pauser.cc +index f55730a..b64ec9d 100644 +--- a/third_party/blink/renderer/platform/scheduler/main_thread/web_scoped_virtual_time_pauser.cc ++++ b/third_party/blink/renderer/platform/scheduler/main_thread/web_scoped_virtual_time_pauser.cc +@@ -28,7 +28,7 @@ + } + + WebScopedVirtualTimePauser::WebScopedVirtualTimePauser( +- WebScopedVirtualTimePauser&& other) noexcept { ++ WebScopedVirtualTimePauser&& other) { + virtual_time_when_paused_ = other.virtual_time_when_paused_; + paused_ = other.paused_; + duration_ = other.duration_; +@@ -39,7 +39,7 @@ + } + + WebScopedVirtualTimePauser& WebScopedVirtualTimePauser::operator=( +- WebScopedVirtualTimePauser&& other) noexcept { ++ WebScopedVirtualTimePauser&& other) { + if (scheduler_ && paused_) + DecrementVirtualTimePauseCount(); + virtual_time_when_paused_ = other.virtual_time_when_paused_; +diff --git a/third_party/blink/renderer/platform/scheduler/public/frame_or_worker_scheduler.h b/third_party/blink/renderer/platform/scheduler/public/frame_or_worker_scheduler.h +index 56915ee..3fdb8cf 100644 +--- a/third_party/blink/renderer/platform/scheduler/public/frame_or_worker_scheduler.h ++++ b/third_party/blink/renderer/platform/scheduler/public/frame_or_worker_scheduler.h +@@ -57,12 +57,11 @@ + + public: + SchedulingAffectingFeatureHandle() = default; +- SchedulingAffectingFeatureHandle( +- SchedulingAffectingFeatureHandle&&) noexcept; ++ SchedulingAffectingFeatureHandle(SchedulingAffectingFeatureHandle&&); + inline ~SchedulingAffectingFeatureHandle() { reset(); } + + SchedulingAffectingFeatureHandle& operator=( +- SchedulingAffectingFeatureHandle&&) noexcept; ++ SchedulingAffectingFeatureHandle&&); + + inline void reset() { + if (scheduler_) +diff --git a/third_party/blink/renderer/platform/scheduler/public/post_cancellable_task.h b/third_party/blink/renderer/platform/scheduler/public/post_cancellable_task.h +index 38cbf63..ae66c73 100644 +--- a/third_party/blink/renderer/platform/scheduler/public/post_cancellable_task.h ++++ b/third_party/blink/renderer/platform/scheduler/public/post_cancellable_task.h +@@ -28,8 +28,8 @@ + TaskHandle(); + ~TaskHandle(); + +- TaskHandle(TaskHandle&&) noexcept; +- TaskHandle& operator=(TaskHandle&&) noexcept; ++ TaskHandle(TaskHandle&&); ++ TaskHandle& operator=(TaskHandle&&); + + // Returns true if the task will run later. Returns false if the task is + // cancelled or the task is run already. +diff --git a/third_party/blink/renderer/platform/weborigin/origin_access_entry.cc b/third_party/blink/renderer/platform/weborigin/origin_access_entry.cc +index 2e9a9d1..c9d777e7 100644 +--- a/third_party/blink/renderer/platform/weborigin/origin_access_entry.cc ++++ b/third_party/blink/renderer/platform/weborigin/origin_access_entry.cc +@@ -59,8 +59,7 @@ + network::mojom::CorsPortMatchMode::kAllowOnlySpecifiedPort, + priority) {} + +-OriginAccessEntry::OriginAccessEntry(OriginAccessEntry&& from) noexcept = +- default; ++OriginAccessEntry::OriginAccessEntry(OriginAccessEntry&& from) = default; + + network::cors::OriginAccessEntry::MatchResult OriginAccessEntry::MatchesOrigin( + const SecurityOrigin& origin) const { +diff --git a/third_party/blink/renderer/platform/weborigin/origin_access_entry.h b/third_party/blink/renderer/platform/weborigin/origin_access_entry.h +index b3e5674..5113a40 100644 +--- a/third_party/blink/renderer/platform/weborigin/origin_access_entry.h ++++ b/third_party/blink/renderer/platform/weborigin/origin_access_entry.h +@@ -58,7 +58,7 @@ + network::mojom::CorsDomainMatchMode, + network::mojom::CorsOriginAccessMatchPriority priority = + network::mojom::CorsOriginAccessMatchPriority::kDefaultPriority); +- OriginAccessEntry(OriginAccessEntry&& from) noexcept; ++ OriginAccessEntry(OriginAccessEntry&& from); + + network::cors::OriginAccessEntry::MatchResult MatchesOrigin( + const SecurityOrigin&) const; +diff --git a/third_party/blink/renderer/platform/wtf/deque.h b/third_party/blink/renderer/platform/wtf/deque.h +index c6fe1b9..4a98ffb 100644 +--- a/third_party/blink/renderer/platform/wtf/deque.h ++++ b/third_party/blink/renderer/platform/wtf/deque.h +@@ -64,8 +64,8 @@ class Deque { + Deque(); + Deque(const Deque&); + Deque& operator=(const Deque&); +- Deque(Deque&&) noexcept; +- Deque& operator=(Deque&&) noexcept; ++ Deque(Deque&&); ++ Deque& operator=(Deque&&); + ~Deque(); + + void FinalizeGarbageCollectedObject() { NOTREACHED(); } +@@ -343,14 +343,14 @@ + } + + template +-inline Deque::Deque(Deque&& other) noexcept ++inline Deque::Deque(Deque&& other) + : start_(0), end_(0) { + Swap(other); + } + + template + inline Deque& +-Deque::operator=(Deque&& other) noexcept { ++Deque::operator=(Deque&& other) { + Swap(other); + return *this; + } +diff --git a/third_party/blink/renderer/platform/wtf/functional.h b/third_party/blink/renderer/platform/wtf/functional.h +index 2c5aeea..5e4b373 100644 +--- a/third_party/blink/renderer/platform/wtf/functional.h ++++ b/third_party/blink/renderer/platform/wtf/functional.h +@@ -117,8 +117,7 @@ + class PassedWrapper final { + public: + explicit PassedWrapper(T&& scoper) : scoper_(std::move(scoper)) {} +- PassedWrapper(PassedWrapper&& other) noexcept +- : scoper_(std::move(other.scoper_)) {} ++ PassedWrapper(PassedWrapper&& other) : scoper_(std::move(other.scoper_)) {} + T MoveOut() const { return std::move(scoper_); } + + private: +@@ -319,9 +318,8 @@ + CrossThreadFunction(const CrossThreadFunction&) = delete; + CrossThreadFunction& operator=(const CrossThreadFunction&) = delete; + +- CrossThreadFunction(CrossThreadFunction&& other) noexcept = default; +- CrossThreadFunction& operator=(CrossThreadFunction&& other) noexcept = +- default; ++ CrossThreadFunction(CrossThreadFunction&& other) = default; ++ CrossThreadFunction& operator=(CrossThreadFunction&& other) = default; + + R Run(Args... args) const & { + return callback_.Run(std::forward(args)...); +@@ -356,9 +354,8 @@ + CrossThreadOnceFunction(const CrossThreadOnceFunction&) = delete; + CrossThreadOnceFunction& operator=(const CrossThreadOnceFunction&) = delete; + +- CrossThreadOnceFunction(CrossThreadOnceFunction&& other) noexcept = default; +- CrossThreadOnceFunction& operator=(CrossThreadOnceFunction&& other) noexcept = +- default; ++ CrossThreadOnceFunction(CrossThreadOnceFunction&& other) = default; ++ CrossThreadOnceFunction& operator=(CrossThreadOnceFunction&& other) = default; + + R Run(Args... args) && { + return std::move(callback_).Run(std::forward(args)...); +diff --git a/third_party/blink/renderer/platform/wtf/hash_map.h b/third_party/blink/renderer/platform/wtf/hash_map.h +index 8a002a8..46b39e0 100644 +--- a/third_party/blink/renderer/platform/wtf/hash_map.h ++++ b/third_party/blink/renderer/platform/wtf/hash_map.h +@@ -106,8 +106,8 @@ + #endif + HashMap(const HashMap&) = default; + HashMap& operator=(const HashMap&) = default; +- HashMap(HashMap&&) noexcept = default; +- HashMap& operator=(HashMap&&) noexcept = default; ++ HashMap(HashMap&&) = default; ++ HashMap& operator=(HashMap&&) = default; + + // For example, HashMap({{1, 11}, {2, 22}, {3, 33}}) will give you + // a HashMap containing a mapping {1 -> 11, 2 -> 22, 3 -> 33}. +diff --git a/third_party/blink/renderer/platform/wtf/hash_set.h b/third_party/blink/renderer/platform/wtf/hash_set.h +index c79e45f1..d7cdeed 100644 +--- a/third_party/blink/renderer/platform/wtf/hash_set.h ++++ b/third_party/blink/renderer/platform/wtf/hash_set.h +@@ -74,8 +74,8 @@ + } + HashSet(const HashSet&) = default; + HashSet& operator=(const HashSet&) = default; +- HashSet(HashSet&&) noexcept = default; +- HashSet& operator=(HashSet&&) noexcept = default; ++ HashSet(HashSet&&) = default; ++ HashSet& operator=(HashSet&&) = default; + + HashSet(std::initializer_list elements); + HashSet& operator=(std::initializer_list elements); +diff --git a/third_party/blink/renderer/platform/wtf/hash_table.h b/third_party/blink/renderer/platform/wtf/hash_table.h +index 373280f..52483ec5 100644 +--- a/third_party/blink/renderer/platform/wtf/hash_table.h ++++ b/third_party/blink/renderer/platform/wtf/hash_table.h +@@ -747,10 +747,10 @@ + } + + HashTable(const HashTable&); +- HashTable(HashTable&&) noexcept; ++ HashTable(HashTable&&); + void swap(HashTable&); + HashTable& operator=(const HashTable&); +- HashTable& operator=(HashTable&&) noexcept; ++ HashTable& operator=(HashTable&&); + + // When the hash table is empty, just return the same iterator for end as + // for begin. This is more efficient because we don't have to skip all the +@@ -1929,7 +1929,7 @@ + typename KeyTraits, + typename Allocator> + HashTable:: +- HashTable(HashTable&& other) noexcept ++ HashTable(HashTable&& other) + : table_(nullptr), + table_size_(0), + key_count_(0), +@@ -2008,7 +2008,7 @@ + typename Allocator> + HashTable& + HashTable:: +-operator=(HashTable&& other) noexcept { ++operator=(HashTable&& other) { + swap(other); + return *this; + } +diff --git a/third_party/blink/renderer/platform/wtf/linked_hash_set.h b/third_party/blink/renderer/platform/wtf/linked_hash_set.h +index 79c3d76d..71ef37a 100644 +--- a/third_party/blink/renderer/platform/wtf/linked_hash_set.h ++++ b/third_party/blink/renderer/platform/wtf/linked_hash_set.h +@@ -121,7 +121,7 @@ + LinkedHashSetNodeBase(const LinkedHashSetNodeBase& other) + : prev_(nullptr), next_(nullptr) {} + +- LinkedHashSetNodeBase(LinkedHashSetNodeBase&& other) noexcept ++ LinkedHashSetNodeBase(LinkedHashSetNodeBase&& other) + : prev_(other.prev_), next_(other.next_) { + other.prev_ = nullptr; + other.next_ = nullptr; +@@ -151,7 +151,7 @@ + LinkedHashSetNodeBase* next) + : LinkedHashSetNodeBase(prev, next), value_(std::move(value)) {} + +- LinkedHashSetNode(LinkedHashSetNode&& other) noexcept ++ LinkedHashSetNode(LinkedHashSetNode&& other) + : LinkedHashSetNodeBase(std::move(other)), + value_(std::move(other.value_)) {} + +@@ -214,9 +214,9 @@ + + LinkedHashSet(); + LinkedHashSet(const LinkedHashSet&); +- LinkedHashSet(LinkedHashSet&&) noexcept; ++ LinkedHashSet(LinkedHashSet&&); + LinkedHashSet& operator=(const LinkedHashSet&); +- LinkedHashSet& operator=(LinkedHashSet&&) noexcept; ++ LinkedHashSet& operator=(LinkedHashSet&&); + + // Needs finalization. The anchor needs to unlink itself from the chain. + ~LinkedHashSet(); +@@ -748,7 +748,7 @@ + } + + template +-inline LinkedHashSet::LinkedHashSet(LinkedHashSet&& other) noexcept ++inline LinkedHashSet::LinkedHashSet(LinkedHashSet&& other) + : anchor_() { + Swap(other); + } +@@ -763,7 +763,7 @@ + + template + inline LinkedHashSet& LinkedHashSet::operator=( +- LinkedHashSet&& other) noexcept { ++ LinkedHashSet&& other) { + Swap(other); + return *this; + } +diff --git a/third_party/blink/renderer/platform/wtf/list_hash_set.h b/third_party/blink/renderer/platform/wtf/list_hash_set.h +index ead6a87..78bd279 100644 +--- a/third_party/blink/renderer/platform/wtf/list_hash_set.h ++++ b/third_party/blink/renderer/platform/wtf/list_hash_set.h +@@ -145,9 +145,9 @@ class ListHashSet { + + ListHashSet(); + ListHashSet(const ListHashSet&); +- ListHashSet(ListHashSet&&) noexcept; ++ ListHashSet(ListHashSet&&); + ListHashSet& operator=(const ListHashSet&); +- ListHashSet& operator=(ListHashSet&&) noexcept; ++ ListHashSet& operator=(ListHashSet&&); + ~ListHashSet(); + + void Swap(ListHashSet&); +@@ -780,8 +780,7 @@ + } + + template +-inline ListHashSet::ListHashSet( +- ListHashSet&& other) noexcept ++inline ListHashSet::ListHashSet(ListHashSet&& other) + : head_(nullptr), tail_(nullptr) { + Swap(other); + } +@@ -796,7 +795,7 @@ + + template + inline ListHashSet& +-ListHashSet::operator=(ListHashSet&& other) noexcept { ++ListHashSet::operator=(ListHashSet&& other) { + Swap(other); + return *this; + } +diff --git a/third_party/blink/renderer/platform/wtf/type_traits_test.cc b/third_party/blink/renderer/platform/wtf/type_traits_test.cc +index 0930b73..1b45d55 100644 +--- a/third_party/blink/renderer/platform/wtf/type_traits_test.cc ++++ b/third_party/blink/renderer/platform/wtf/type_traits_test.cc +@@ -158,7 +158,7 @@ + STACK_ALLOCATED(); + + public: +- CopyAssignmentDeleted& operator=(CopyAssignmentDeleted&&) noexcept; ++ CopyAssignmentDeleted& operator=(CopyAssignmentDeleted&&); + + private: + CopyAssignmentDeleted& operator=(const CopyAssignmentDeleted&) = delete; +@@ -173,7 +173,7 @@ + STACK_ALLOCATED(); + + public: +- CopyAssignmentPrivate& operator=(CopyAssignmentPrivate&&) noexcept; ++ CopyAssignmentPrivate& operator=(CopyAssignmentPrivate&&); + + private: + CopyAssignmentPrivate& operator=(const CopyAssignmentPrivate&); +@@ -188,7 +188,7 @@ + STACK_ALLOCATED(); + + public: +- CopyAssignmentUndeclared& operator=(CopyAssignmentUndeclared&&) noexcept; ++ CopyAssignmentUndeclared& operator=(CopyAssignmentUndeclared&&); + }; + + static_assert(!std::is_copy_assignable::value, +diff --git a/third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer_contents.h b/third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer_contents.h +index 3f44cd2..ee7c89a 100644 +--- a/third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer_contents.h ++++ b/third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer_contents.h +@@ -68,7 +68,7 @@ + deleter_(deleter), + deleter_info_(deleter_info) {} + // Move constructor +- DataHandle(DataHandle&& other) noexcept { *this = std::move(other); } ++ DataHandle(DataHandle&& other) { *this = std::move(other); } + ~DataHandle() { + if (!data_) + return; +diff --git a/third_party/blink/renderer/platform/wtf/vector.h b/third_party/blink/renderer/platform/wtf/vector.h +index 2783c2b..43a27f7 100644 +--- a/third_party/blink/renderer/platform/wtf/vector.h ++++ b/third_party/blink/renderer/platform/wtf/vector.h +@@ -1018,8 +1018,8 @@ + Vector& operator=(const Vector&); + + // Moving. +- Vector(Vector&&) noexcept; +- Vector& operator=(Vector&&) noexcept; ++ Vector(Vector&&); ++ Vector& operator=(Vector&&); + + // Construct with an initializer list. You can do e.g. + // Vector v({1, 2, 3}); +@@ -1459,7 +1459,7 @@ + + template + Vector::Vector( +- Vector&& other) noexcept { ++ Vector&& other) { + size_ = 0; + // It's a little weird to implement a move constructor using swap but this + // way we don't have to add a move constructor to VectorBuffer. +@@ -1468,7 +1468,7 @@ + + template + Vector& Vector:: +-operator=(Vector&& other) noexcept { ++operator=(Vector&& other) { + swap(other); + return *this; + } +diff --git a/third_party/blink/renderer/platform/wtf/vector_test.cc b/third_party/blink/renderer/platform/wtf/vector_test.cc +index aa8a138..788cc2bb 100644 +--- a/third_party/blink/renderer/platform/wtf/vector_test.cc ++++ b/third_party/blink/renderer/platform/wtf/vector_test.cc +@@ -420,8 +420,8 @@ + class MojoMoveOnlyType final { + public: + MojoMoveOnlyType(); +- MojoMoveOnlyType(MojoMoveOnlyType&&) noexcept; +- MojoMoveOnlyType& operator=(MojoMoveOnlyType&&) noexcept; ++ MojoMoveOnlyType(MojoMoveOnlyType&&); ++ MojoMoveOnlyType& operator=(MojoMoveOnlyType&&); + ~MojoMoveOnlyType(); + + private: +diff --git a/third_party/blink/renderer/platform/wtf/wtf_test_helper.h b/third_party/blink/renderer/platform/wtf/wtf_test_helper.h +index e797445..8f31365 100644 +--- a/third_party/blink/renderer/platform/wtf/wtf_test_helper.h ++++ b/third_party/blink/renderer/platform/wtf/wtf_test_helper.h +@@ -36,9 +36,9 @@ + public: + explicit MoveOnly(int i = 0) : i_(i) {} + +- MoveOnly(MoveOnly&& other) noexcept : i_(other.i_) { other.i_ = 0; } ++ MoveOnly(MoveOnly&& other) : i_(other.i_) { other.i_ = 0; } + +- MoveOnly& operator=(MoveOnly&& other) noexcept { ++ MoveOnly& operator=(MoveOnly&& other) { + if (this != &other) { + i_ = other.i_; + other.i_ = 0; +@@ -62,12 +62,12 @@ + + explicit MoveOnlyHashValue(int value = kEmpty, int id = 0) + : value_(value), id_(id) {} +- MoveOnlyHashValue(MoveOnlyHashValue&& other) noexcept ++ MoveOnlyHashValue(MoveOnlyHashValue&& other) + : value_(other.value_), id_(other.id_) { + other.value_ = kMovedOut; + other.id_ = 0; + } +- MoveOnlyHashValue& operator=(MoveOnlyHashValue&& other) noexcept { ++ MoveOnlyHashValue& operator=(MoveOnlyHashValue&& other) { + value_ = other.value_; + id_ = other.id_; + other.value_ = kMovedOut; diff --git a/chromium-78.0.3904.70-base-gcc-no-alignas.patch b/chromium-78.0.3904.70-base-gcc-no-alignas.patch new file mode 100644 index 00000000..4856c36e --- /dev/null +++ b/chromium-78.0.3904.70-base-gcc-no-alignas.patch @@ -0,0 +1,68 @@ +diff -up chromium-77.0.3865.75/base/task/promise/dependent_list.h.base-gcc-no-alignas chromium-77.0.3865.75/base/task/promise/dependent_list.h +--- chromium-77.0.3865.75/base/task/promise/dependent_list.h.base-gcc-no-alignas 2019-09-13 21:45:51.873172347 +0200 ++++ chromium-77.0.3865.75/base/task/promise/dependent_list.h 2019-09-13 21:46:21.661522514 +0200 +@@ -59,7 +59,7 @@ class BASE_EXPORT DependentList { + + // Align Node on an 8-byte boundary to ensure the first 3 bits are 0 and can + // be used to store additional state (see static_asserts below). +- class BASE_EXPORT alignas(8) Node { ++ class BASE_EXPORT ALIGNAS(8) Node { + public: + Node(); + explicit Node(Node&& other) noexcept; +--- a/third_party/protobuf/src/google/protobuf/arena.h ++++ b/third_party/protobuf/src/google/protobuf/arena.h +@@ -245,7 +245,7 @@ struct ArenaOptions { + // well as protobuf container types like RepeatedPtrField and Map. The protocol + // is internal to protobuf and is not guaranteed to be stable. Non-proto types + // should not rely on this protocol. +-class PROTOBUF_EXPORT alignas(8) Arena final { ++class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final { + public: + // Arena constructor taking custom options. See ArenaOptions below for + // descriptions of the options available. +--- a/third_party/protobuf/src/google/protobuf/port_def.inc ++++ b/third_party/protobuf/src/google/protobuf/port_def.inc +@@ -528,6 +528,35 @@ PROTOBUF_EXPORT_TEMPLATE_TEST(DEFAULT, __declspec(dllimport)); + #undef IN + #endif // _MSC_VER + ++// Specify memory alignment for structs, classes, etc. ++// Use like: ++// class PROTOBUF_ALIGNAS(16) MyClass { ... } ++// PROTOBUF_ALIGNAS(16) int array[4]; ++// ++// In most places you can use the C++11 keyword "alignas", which is preferred. ++// ++// But compilers have trouble mixing __attribute__((...)) syntax with ++// alignas(...) syntax. ++// ++// Doesn't work in clang or gcc: ++// struct alignas(16) __attribute__((packed)) S { char c; }; ++// Works in clang but not gcc: ++// struct __attribute__((packed)) alignas(16) S2 { char c; }; ++// Works in clang and gcc: ++// struct alignas(16) S3 { char c; } __attribute__((packed)); ++// ++// There are also some attributes that must be specified *before* a class ++// definition: visibility (used for exporting functions/classes) is one of ++// these attributes. This means that it is not possible to use alignas() with a ++// class that is marked as exported. ++#if defined(_MSC_VER) ++#define PROTOBUF_ALIGNAS(byte_alignment) __declspec(align(byte_alignment)) ++#elif defined(__GNUC__) ++#define PROTOBUF_ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment))) ++#else ++#define PROTOBUF_ALIGNAS(byte_alignment) alignas(byte_alignment) ++#endif ++ + #if defined(__clang__) + #pragma clang diagnostic push + // TODO(gerbens) ideally we cleanup the code. But a cursory try shows many +--- a/third_party/protobuf/src/google/protobuf/port_undef.inc ++++ b/third_party/protobuf/src/google/protobuf/port_undef.inc +@@ -80,6 +80,7 @@ + #undef PROTOBUF_EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA__declspec + #undef PROTOBUF_EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllexport + #undef PROTOBUF_EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllimport ++#undef PROTOBUF_ALIGNAS diff --git a/chromium-78.0.3904.70-gcc-DohUpgradeEntry-nonconst.patch b/chromium-78.0.3904.70-gcc-DohUpgradeEntry-nonconst.patch new file mode 100644 index 00000000..cb436ecd --- /dev/null +++ b/chromium-78.0.3904.70-gcc-DohUpgradeEntry-nonconst.patch @@ -0,0 +1,49 @@ +diff -up chromium-78.0.3904.70/net/dns/dns_util.cc.gcc-DohUpgradeEntry-nonconst chromium-78.0.3904.70/net/dns/dns_util.cc +--- chromium-78.0.3904.70/net/dns/dns_util.cc.gcc-DohUpgradeEntry-nonconst 2019-10-21 15:06:38.000000000 -0400 ++++ chromium-78.0.3904.70/net/dns/dns_util.cc 2019-10-23 12:55:27.886546918 -0400 +@@ -139,12 +139,12 @@ struct DohUpgradeEntry { + const DnsConfig::DnsOverHttpsServerConfig dns_over_https_config; + }; + +-const std::vector& GetDohUpgradeList() { ++const std::vector& GetDohUpgradeList() { + // The provider names in these entries should be kept in sync with the + // DohProviderId histogram suffix list in + // tools/metrics/histograms/histograms.xml. +- static const base::NoDestructor> +- upgradable_servers({ ++ static const base::NoDestructor> ++ upgradable_servers(std::initializer_list{ + DohUpgradeEntry( + "CleanBrowsingAdult", + {"185.228.168.10", "185.228.169.11", "2a0d:2a00:1::1", +@@ -222,8 +222,7 @@ const std::vector + std::vector GetDohUpgradeEntriesFromNameservers( + const std::vector& dns_servers, + const std::vector& excluded_providers) { +- const std::vector& upgradable_servers = +- GetDohUpgradeList(); ++ const std::vector& upgradable_servers = GetDohUpgradeList(); + std::vector entries; + + for (const auto& server : dns_servers) { +@@ -417,8 +416,7 @@ std::vector& excluded_providers) { +- const std::vector& upgradable_servers = +- GetDohUpgradeList(); ++ const std::vector& upgradable_servers = GetDohUpgradeList(); + std::vector doh_servers; + + if (dot_server.empty()) +@@ -451,8 +449,7 @@ GetDohUpgradeServersFromNameservers( + + std::string GetDohProviderIdForHistogramFromDohConfig( + const DnsConfig::DnsOverHttpsServerConfig& doh_server) { +- const std::vector& upgradable_servers = +- GetDohUpgradeList(); ++ const std::vector& upgradable_servers = GetDohUpgradeList(); + for (const auto& upgrade_entry : upgradable_servers) { + if (doh_server.server_template == + upgrade_entry.dns_over_https_config.server_template) { diff --git a/chromium-78.0.3904.70-gcc-fix-invalid-pragma.patch b/chromium-78.0.3904.70-gcc-fix-invalid-pragma.patch new file mode 100644 index 00000000..eb0efbd4 --- /dev/null +++ b/chromium-78.0.3904.70-gcc-fix-invalid-pragma.patch @@ -0,0 +1,16 @@ +diff -up chromium-78.0.3904.70/base/allocator/debugallocation_shim.cc.invalid-pragma chromium-78.0.3904.70/base/allocator/debugallocation_shim.cc +--- chromium-78.0.3904.70/base/allocator/debugallocation_shim.cc.invalid-pragma 2019-10-23 10:00:41.361932768 -0400 ++++ chromium-78.0.3904.70/base/allocator/debugallocation_shim.cc 2019-10-23 10:02:09.778100948 -0400 +@@ -7,9 +7,10 @@ + // AFDO can mess with them. Better not to use AFDO there. This is a + // temporary hack. We will add a mechanism in the build system to + // avoid using -fauto-profile for tcmalloc files. +-#if !defined(__clang__) && (defined(OS_CHROMEOS) || __GNUC__ > 5) ++#if !defined(__clang__) && \ ++ (defined(OS_CHROMEOS) || (__GNUC__ > 5 && __GNUC__ < 7)) + // Note that this option only seems to be available in the chromeos GCC 4.9 +-// toolchain, and stock GCC 5 and up. ++// toolchain, and stock GCC 5 upto 7. + #pragma GCC optimize ("no-auto-profile") + #endif + diff --git a/chromium-78.0.3904.70-gcc-mark-CheckOpResult-constexpr.patch b/chromium-78.0.3904.70-gcc-mark-CheckOpResult-constexpr.patch new file mode 100644 index 00000000..e5502cf0 --- /dev/null +++ b/chromium-78.0.3904.70-gcc-mark-CheckOpResult-constexpr.patch @@ -0,0 +1,12 @@ +diff -up chromium-78.0.3904.70/base/logging.h.constexpr chromium-78.0.3904.70/base/logging.h +--- chromium-78.0.3904.70/base/logging.h.constexpr 2019-10-23 10:06:53.434313793 -0400 ++++ chromium-78.0.3904.70/base/logging.h 2019-10-23 10:07:17.490853038 -0400 +@@ -530,7 +530,7 @@ BASE_EXPORT extern std::ostream* g_swall + class CheckOpResult { + public: + // |message| must be non-null if and only if the check failed. +- CheckOpResult(std::string* message) : message_(message) {} ++ constexpr CheckOpResult(std::string* message) : message_(message) {} + // Returns true if the check succeeded. + operator bool() const { return !message_; } + // Returns the message. diff --git a/chromium-78.0.3904.70-gcc-sizet-fix.patch b/chromium-78.0.3904.70-gcc-sizet-fix.patch new file mode 100644 index 00000000..b95b0ed5 --- /dev/null +++ b/chromium-78.0.3904.70-gcc-sizet-fix.patch @@ -0,0 +1,20 @@ +diff -up chromium-78.0.3904.70/base/containers/intrusive_heap.h.gcc-sizet chromium-78.0.3904.70/base/containers/intrusive_heap.h +--- chromium-78.0.3904.70/base/containers/intrusive_heap.h.gcc-sizet 2019-10-23 11:02:56.767907986 -0400 ++++ chromium-78.0.3904.70/base/containers/intrusive_heap.h 2019-10-23 11:04:58.317351636 -0400 +@@ -131,6 +131,7 @@ + + #include + #include ++#include + #include + #include + #include +@@ -149,7 +150,7 @@ namespace base { + // in place. + class BASE_EXPORT HeapHandle { + public: +- enum : size_t { kInvalidIndex = -1 }; ++ enum : size_t { kInvalidIndex = std::numeric_limits::max() }; + + constexpr HeapHandle() = default; + constexpr HeapHandle(const HeapHandle& other) = default; diff --git a/chromium-78.0.3904.70-gcc9-drop-rsp-clobber.patch b/chromium-78.0.3904.70-gcc9-drop-rsp-clobber.patch new file mode 100644 index 00000000..6785b092 --- /dev/null +++ b/chromium-78.0.3904.70-gcc9-drop-rsp-clobber.patch @@ -0,0 +1,24 @@ +diff -up chromium-78.0.3904.70/third_party/tcmalloc/chromium/src/base/linux_syscall_support.h.gcc9 chromium-78.0.3904.70/third_party/tcmalloc/chromium/src/base/linux_syscall_support.h +--- chromium-78.0.3904.70/third_party/tcmalloc/chromium/src/base/linux_syscall_support.h.gcc9 2019-10-23 08:58:16.153251961 -0400 ++++ chromium-78.0.3904.70/third_party/tcmalloc/chromium/src/base/linux_syscall_support.h 2019-10-23 08:58:36.896862347 -0400 +@@ -1486,7 +1486,7 @@ struct kernel_stat { + "d"(LSS_SYSCALL_ARG(parent_tidptr)), + "r"(LSS_SYSCALL_ARG(newtls)), + "r"(LSS_SYSCALL_ARG(child_tidptr)) +- : "rsp", "memory", "r8", "r10", "r11", "rcx"); ++ : "memory", "r8", "r10", "r11", "rcx"); + } + LSS_RETURN(int, __res); + } +diff -up chromium-78.0.3904.70/third_party/tcmalloc/vendor/src/base/linux_syscall_support.h.gcc9 chromium-78.0.3904.70/third_party/tcmalloc/vendor/src/base/linux_syscall_support.h +--- chromium-78.0.3904.70/third_party/tcmalloc/vendor/src/base/linux_syscall_support.h.gcc9 2019-10-23 08:58:59.623435488 -0400 ++++ chromium-78.0.3904.70/third_party/tcmalloc/vendor/src/base/linux_syscall_support.h 2019-10-23 08:59:16.113125772 -0400 +@@ -1485,7 +1485,7 @@ struct kernel_stat { + "d"(LSS_SYSCALL_ARG(parent_tidptr)), + "r"(LSS_SYSCALL_ARG(newtls)), + "r"(LSS_SYSCALL_ARG(child_tidptr)) +- : "rsp", "memory", "r8", "r10", "r11", "rcx"); ++ : "memory", "r8", "r10", "r11", "rcx"); + } + LSS_RETURN(int, __res); + } diff --git a/chromium-78.0.3904.70-unbundle-zlib.patch b/chromium-78.0.3904.70-unbundle-zlib.patch new file mode 100644 index 00000000..155990eb --- /dev/null +++ b/chromium-78.0.3904.70-unbundle-zlib.patch @@ -0,0 +1,12 @@ +diff -up chromium-78.0.3904.70/third_party/perfetto/gn/BUILD.gn.unbundle-zlib chromium-78.0.3904.70/third_party/perfetto/gn/BUILD.gn +--- chromium-78.0.3904.70/third_party/perfetto/gn/BUILD.gn.unbundle-zlib 2019-10-23 09:25:44.419884187 -0400 ++++ chromium-78.0.3904.70/third_party/perfetto/gn/BUILD.gn 2019-10-23 09:29:53.553442745 -0400 +@@ -276,7 +276,7 @@ if (enable_perfetto_trace_processor || e + "//buildtools:zlib", + ] + } else { +- public_configs = [ "//third_party/zlib:zlib_config" ] ++ public_configs = [ "//third_party/zlib:system_zlib" ] + public_deps = [ + "//third_party/zlib", + ] diff --git a/chromium-78.0.3904.70-v8-tracedreference-fix.patch b/chromium-78.0.3904.70-v8-tracedreference-fix.patch new file mode 100644 index 00000000..789bdd01 --- /dev/null +++ b/chromium-78.0.3904.70-v8-tracedreference-fix.patch @@ -0,0 +1,302 @@ +diff -up chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_embedder_graph_builder.cc.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_embedder_graph_builder.cc +--- chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_embedder_graph_builder.cc.v8-tracedreference-fix 2019-10-21 15:06:42.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_embedder_graph_builder.cc 2019-10-23 14:30:25.679541652 -0400 +@@ -173,8 +173,9 @@ class GC_PLUGIN_IGNORE( + uint16_t class_id) override; + + // v8::EmbedderHeapTracer::TracedGlobalHandleVisitor override. +- void VisitTracedGlobalHandle( +- const v8::TracedGlobal& value) override; ++ void VisitTracedReference( ++ const v8::TracedReference& value) override; ++ void VisitTracedGlobalHandle(const v8::TracedGlobal&) override; + + // Visitor overrides. + void VisitRoot(void*, TraceDescriptor, const base::Location&) final; +@@ -508,8 +509,8 @@ void V8EmbedderGraphBuilder::VisitPersis + } + } + +-void V8EmbedderGraphBuilder::VisitTracedGlobalHandle( +- const v8::TracedGlobal& value) { ++void V8EmbedderGraphBuilder::VisitTracedReference( ++ const v8::TracedReference& value) { + const uint16_t class_id = value.WrapperClassId(); + if (class_id != WrapperTypeInfo::kNodeClassId && + class_id != WrapperTypeInfo::kObjectClassId) +@@ -517,6 +518,11 @@ void V8EmbedderGraphBuilder::VisitTraced + VisitPersistentHandleInternal(value.As().Get(isolate_), class_id); + } + ++void V8EmbedderGraphBuilder::VisitTracedGlobalHandle( ++ const v8::TracedGlobal&) { ++ CHECK(false) << "Blink does not use v8::TracedGlobal."; ++} ++ + void V8EmbedderGraphBuilder::VisitPersistentHandle( + v8::Persistent* value, + uint16_t class_id) { +diff -up chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_gc_controller.cc.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_gc_controller.cc +--- chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_gc_controller.cc.v8-tracedreference-fix 2019-10-21 15:06:42.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/bindings/core/v8/v8_gc_controller.cc 2019-10-23 14:30:25.683541568 -0400 +@@ -260,7 +260,11 @@ class DOMWrapperForwardingVisitor final + VisitHandle(value, class_id); + } + +- void VisitTracedGlobalHandle(const v8::TracedGlobal& value) final { ++ void VisitTracedGlobalHandle(const v8::TracedGlobal&) final { ++ CHECK(false) << "Blink does not use v8::TracedGlobal."; ++ } ++ ++ void VisitTracedReference(const v8::TracedReference& value) final { + VisitHandle(&value, value.WrapperClassId()); + } + +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/dom_data_store.h.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/dom_data_store.h +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/dom_data_store.h.v8-tracedreference-fix 2019-10-21 15:06:44.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/dom_data_store.h 2019-10-23 14:30:25.685541526 -0400 +@@ -229,6 +229,11 @@ class DOMDataStore { + DOMWorldWrapperReference(v8::Isolate* isolate, v8::Local handle) + : TraceWrapperV8Reference(isolate, handle) {} + ++ ~DOMWorldWrapperReference() { ++ // Destruction of a reference should clear it immediately. ++ Clear(); ++ } ++ + // Move support without write barrier. + DOMWorldWrapperReference(DOMWorldWrapperReference&& other) + : TraceWrapperV8Reference() { +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/script_wrappable.h.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/script_wrappable.h +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/script_wrappable.h.v8-tracedreference-fix 2019-10-21 15:06:44.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/script_wrappable.h 2019-10-23 14:30:25.687541484 -0400 +@@ -161,6 +161,11 @@ class PLATFORM_EXPORT ScriptWrappable + return main_world_wrapper_.NewLocal(isolate); + } + ++ static_assert( ++ std::is_trivially_destructible< ++ TraceWrapperV8Reference>::value, ++ "TraceWrapperV8Reference should be trivially destructible."); ++ + TraceWrapperV8Reference main_world_wrapper_; + + DISALLOW_COPY_AND_ASSIGN(ScriptWrappable); +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h.v8-tracedreference-fix 2019-10-21 15:06:44.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h 2019-10-23 14:30:25.688541463 -0400 +@@ -11,15 +11,6 @@ + #include "third_party/blink/renderer/platform/heap/unified_heap_marking_visitor.h" + #include "v8/include/v8.h" + +-namespace v8 { +- +-template +-struct TracedGlobalTrait> { +- static constexpr bool kRequiresExplicitDestruction = false; +-}; +- +-} // namespace v8 +- + namespace blink { + + /** +@@ -50,8 +41,8 @@ class TraceWrapperV8Reference { + + bool IsEmpty() const { return handle_.IsEmpty(); } + void Clear() { handle_.Reset(); } +- ALWAYS_INLINE const v8::TracedGlobal& Get() const { return handle_; } +- ALWAYS_INLINE v8::TracedGlobal& Get() { return handle_; } ++ ALWAYS_INLINE const v8::TracedReference& Get() const { return handle_; } ++ ALWAYS_INLINE v8::TracedReference& Get() { return handle_; } + + template + const TraceWrapperV8Reference& Cast() const { +@@ -124,7 +115,7 @@ class TraceWrapperV8Reference { + UnifiedHeapMarkingVisitor::WriteBarrier(UnsafeCast()); + } + +- v8::TracedGlobal handle_; ++ v8::TracedReference handle_; + }; + + } // namespace blink +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/wrapper_type_info.h.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/wrapper_type_info.h +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/wrapper_type_info.h.v8-tracedreference-fix 2019-10-21 15:06:44.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/bindings/wrapper_type_info.h 2019-10-23 14:30:25.689541442 -0400 +@@ -122,7 +122,7 @@ struct WrapperTypeInfo { + wrapper->SetWrapperClassId(wrapper_class_id); + } + +- void ConfigureWrapper(v8::TracedGlobal* wrapper) const { ++ void ConfigureWrapper(v8::TracedReference* wrapper) const { + wrapper->SetWrapperClassId(wrapper_class_id); + } + +@@ -177,7 +177,7 @@ inline T* GetInternalField(const v8::Per + } + + template +-inline T* GetInternalField(const v8::TracedGlobal& global) { ++inline T* GetInternalField(const v8::TracedReference& global) { + DCHECK_LT(offset, v8::Object::InternalFieldCount(global)); + return reinterpret_cast( + v8::Object::GetAlignedPointerFromInternalField(global, offset)); +@@ -198,7 +198,7 @@ inline ScriptWrappable* ToScriptWrappabl + } + + inline ScriptWrappable* ToScriptWrappable( +- const v8::TracedGlobal& wrapper) { ++ const v8::TracedReference& wrapper) { + return GetInternalField(wrapper); + } + +@@ -219,7 +219,8 @@ inline void* ToUntypedWrappable(const v8 + return GetInternalField(wrapper); + } + +-inline void* ToUntypedWrappable(const v8::TracedGlobal& wrapper) { ++inline void* ToUntypedWrappable( ++ const v8::TracedReference& wrapper) { + return GetInternalField(wrapper); + } + +@@ -233,7 +234,7 @@ inline const WrapperTypeInfo* ToWrapperT + } + + inline const WrapperTypeInfo* ToWrapperTypeInfo( +- const v8::TracedGlobal& wrapper) { ++ const v8::TracedReference& wrapper) { + return GetInternalField(wrapper); + } + +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/thread_state.cc.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/thread_state.cc +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/thread_state.cc.v8-tracedreference-fix 2019-10-21 15:06:45.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/thread_state.cc 2019-10-23 14:30:25.693541359 -0400 +@@ -1451,11 +1451,15 @@ class ClearReferencesInDeadObjectsVisito + value->Reset(); + } + +- void VisitTracedGlobalHandle(const v8::TracedGlobal& value) final { ++ void VisitTracedGlobalHandle(const v8::TracedGlobal&) final { ++ CHECK(false) << "Blink does not use v8::TracedGlobal."; ++ } ++ ++ void VisitTracedReference(const v8::TracedReference& value) final { + // TODO(mlippautz): Avoid const_cast after changing the API to allow +- // modificaton of the TracedGlobal handle. +- if (InDeadObject(&const_cast&>(value))) +- const_cast&>(value).Reset(); ++ // modificaton of the handle. ++ if (InDeadObject(&const_cast&>(value))) ++ const_cast&>(value).Reset(); + } + + private: +@@ -1584,11 +1588,15 @@ class UnpoisonHandlesVisitor final + VisitSlot(value, sizeof(v8::Persistent)); + } + +- void VisitTracedGlobalHandle(const v8::TracedGlobal& value) final { ++ void VisitTracedGlobalHandle(const v8::TracedGlobal&) final { ++ CHECK(false) << "Blink does not use v8::TracedGlobal."; ++ } ++ ++ void VisitTracedReference(const v8::TracedReference& value) final { + // TODO(mlippautz): Avoid const_cast after changing the API to allow +- // modificaton of the TracedGlobal handle. +- VisitSlot(&const_cast&>(value), +- sizeof(v8::TracedGlobal)); ++ // modificaton of the handle. ++ VisitSlot(&const_cast&>(value), ++ sizeof(v8::TracedReference)); + } + + private: +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.cc.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.cc +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.cc.v8-tracedreference-fix 2019-10-21 15:06:45.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.cc 2019-10-23 14:32:34.722840885 -0400 +@@ -147,16 +147,19 @@ bool UnifiedHeapController::IsTracingDon + return is_tracing_done_; + } + +-bool UnifiedHeapController::IsRootForNonTracingGCInternal( +- const v8::TracedGlobal& handle) { ++namespace { ++ ++bool IsRootForNonTracingGCInternal( ++ const v8::TracedReference& handle) { + const uint16_t class_id = handle.WrapperClassId(); +- // Stand-alone TracedGlobal reference or kCustomWrappableId. Keep as root as ++ // Stand-alone reference or kCustomWrappableId. Keep as root as + // we don't know better. + if (class_id != WrapperTypeInfo::kNodeClassId && + class_id != WrapperTypeInfo::kObjectClassId) + return true; + +- const v8::TracedGlobal& traced = handle.As(); ++ const v8::TracedReference& traced = ++ handle.template As(); + if (ToWrapperTypeInfo(traced)->IsActiveScriptWrappable() && + ToScriptWrappable(traced)->HasPendingActivity()) { + return true; +@@ -169,8 +172,10 @@ bool UnifiedHeapController::IsRootForNon + return false; + } + ++} // namespace ++ + void UnifiedHeapController::ResetHandleInNonTracingGC( +- const v8::TracedGlobal& handle) { ++ const v8::TracedReference& handle) { + const uint16_t class_id = handle.WrapperClassId(); + // Only consider handles that have not been treated as roots, see + // IsRootForNonTracingGCInternal. +@@ -178,15 +183,21 @@ void UnifiedHeapController::ResetHandleI + class_id != WrapperTypeInfo::kObjectClassId) + return; + +- const v8::TracedGlobal& traced = handle.As(); ++ const v8::TracedReference& traced = handle.As(); + ToScriptWrappable(traced)->UnsetWrapperIfAny(); + } + + bool UnifiedHeapController::IsRootForNonTracingGC( +- const v8::TracedGlobal& handle) { ++ const v8::TracedReference& handle) { + return IsRootForNonTracingGCInternal(handle); + } + ++bool UnifiedHeapController::IsRootForNonTracingGC( ++ const v8::TracedGlobal& handle) { ++ CHECK(false) << "Blink does not use v8::TracedGlobal."; ++ return false; ++} ++ + void UnifiedHeapController::ReportBufferedAllocatedSizeIfPossible() { + DCHECK(base::FeatureList::IsEnabled( + blink::features::kBlinkHeapUnifiedGCScheduling)); +diff -up chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.h.v8-tracedreference-fix chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.h +--- chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.h.v8-tracedreference-fix 2019-10-21 15:06:45.000000000 -0400 ++++ chromium-78.0.3904.70/third_party/blink/renderer/platform/heap/unified_heap_controller.h 2019-10-23 14:30:25.695541317 -0400 +@@ -45,8 +45,9 @@ class PLATFORM_EXPORT UnifiedHeapControl + void RegisterV8References(const std::vector>&) final; + bool AdvanceTracing(double) final; + bool IsTracingDone() final; ++ bool IsRootForNonTracingGC(const v8::TracedReference&) final; + bool IsRootForNonTracingGC(const v8::TracedGlobal&) final; +- void ResetHandleInNonTracingGC(const v8::TracedGlobal&) final; ++ void ResetHandleInNonTracingGC(const v8::TracedReference&) final; + + ThreadState* thread_state() const { return thread_state_; } + +@@ -59,9 +60,6 @@ class PLATFORM_EXPORT UnifiedHeapControl + void DecreaseAllocatedSpace(size_t) final {} + + private: +- static bool IsRootForNonTracingGCInternal( +- const v8::TracedGlobal& handle); +- + void ReportBufferedAllocatedSizeIfPossible(); + + ThreadState* const thread_state_; diff --git a/chromium-78.0.3904.70-vtable-symbol-undefined.patch b/chromium-78.0.3904.70-vtable-symbol-undefined.patch new file mode 100644 index 00000000..13751a2a --- /dev/null +++ b/chromium-78.0.3904.70-vtable-symbol-undefined.patch @@ -0,0 +1,11 @@ +diff -up chromium-78.0.3904.70/net/quic/platform/impl/quic_default_proof_providers_impl.cc.vtable-symbol-undefined chromium-78.0.3904.70/net/quic/platform/impl/quic_default_proof_providers_impl.cc +--- chromium-78.0.3904.70/net/quic/platform/impl/quic_default_proof_providers_impl.cc.vtable-symbol-undefined 2019-10-23 09:12:08.754351798 -0400 ++++ chromium-78.0.3904.70/net/quic/platform/impl/quic_default_proof_providers_impl.cc 2019-10-23 09:19:28.278431430 -0400 +@@ -18,6 +18,7 @@ + #include "net/quic/crypto/proof_verifier_chromium.h" + #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" + #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h" ++#include "net/quic/platform/impl/quic_flags_impl.cc" + + DEFINE_QUIC_COMMAND_LINE_FLAG( + bool, diff --git a/chromium-latest.py b/chromium-latest.py index 87889ad8..5af86286 100755 --- a/chromium-latest.py +++ b/chromium-latest.py @@ -1,5 +1,5 @@ -#!/usr/bin/python -# Copyright 2010,2015-2016 Tom Callaway +#!/usr/bin/python3 +# Copyright 2010,2015-2019 Tom Callaway # Copyright 2013-2016 Tomas Popela # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the @@ -32,9 +32,9 @@ import hashlib import locale import os import shutil -import StringIO +import io import sys -import urllib +import urllib.request, urllib.parse, urllib.error chromium_url = "http://commondatastorage.googleapis.com/chromium-browser-official/" @@ -59,22 +59,22 @@ def dlProgress(count, blockSize, totalSize): def delete_chromium_dir(ch_dir): full_dir = "%s/%s" % (latest_dir, ch_dir) - print 'Deleting %s ' % full_dir + print('Deleting %s ' % full_dir) if os.path.isdir(full_dir): shutil.rmtree(full_dir) - print '[DONE]' + print('[DONE]') else: - print '[NOT FOUND]' + print('[NOT FOUND]') def delete_chromium_files(files): full_path = "%s/%s" % (latest_dir, files) - print 'Deleting ' + full_path + ' ', + print('Deleting ' + full_path + ' ', end=' ') for filename in glob.glob(full_path): - print 'Deleting ' + filename + ' ', + print('Deleting ' + filename + ' ', end=' ') os.remove(filename) - print '[DONE]' + print('[DONE]') def check_omahaproxy(channel="stable"): @@ -82,20 +82,20 @@ def check_omahaproxy(channel="stable"): version = 0 status_url = "http://omahaproxy.appspot.com/all?os=linux&channel=" + channel - usock = urllib.urlopen(status_url) - status_dump = usock.read() + usock = urllib.request.urlopen(status_url) + status_dump = usock.read().decode('utf-8') usock.close() - status_list = StringIO.StringIO(status_dump) + status_list = io.StringIO(status_dump) status_reader = list(csv.reader(status_list, delimiter=',')) linux_channels = [s for s in status_reader if "linux" in s] linux_channel = [s for s in linux_channels if channel in s] version = linux_channel[0][2] if version == 0: - print 'I could not find the latest %s build. Bailing out.' % channel + print('I could not find the latest %s build. Bailing out.' % channel) sys.exit(1) else: - print 'Latest Chromium Version on %s at %s is %s' % (channel, status_url, version) + print('Latest Chromium Version on %s at %s is %s' % (channel, status_url, version)) return version @@ -119,27 +119,27 @@ def download_file_and_compare_hashes(file_to_download): # Let's make sure we haven't already downloaded it. tarball_local_file = "./%s" % file_to_download if os.path.isfile(tarball_local_file): - print "%s already exists!" % file_to_download + print("%s already exists!" % file_to_download) else: path = '%s%s' % (chromium_url, file_to_download) - print "Downloading %s" % path + print("Downloading %s" % path) # Perhaps look at using python-progressbar at some point? - info=urllib.urlretrieve(path, file_to_download, reporthook=dlProgress)[1] - urllib.urlcleanup() - print "" + info=urllib.request.urlretrieve(path, file_to_download, reporthook=dlProgress)[1] + urllib.request.urlcleanup() + print("") if (info["Content-Type"] != "application/x-tar"): - print 'Chromium tarballs for %s are not on servers.' % file_to_download + print('Chromium tarballs for %s are not on servers.' % file_to_download) remove_file_if_exists (file_to_download) sys.exit(1) hashes_local_file = "./%s" % hashes_file if not os.path.isfile(hashes_local_file): path = '%s%s' % (chromium_url, hashes_file) - print "Downloading %s" % path + print("Downloading %s" % path) # Perhaps look at using python-progressbar at some point? - info=urllib.urlretrieve(path, hashes_file, reporthook=dlProgress)[1] - urllib.urlcleanup() - print "" + info=urllib.request.urlretrieve(path, hashes_file, reporthook=dlProgress)[1] + urllib.request.urlcleanup() + print("") if os.path.isfile(hashes_local_file): with open(hashes_local_file, "r") as input_file: @@ -149,12 +149,12 @@ def download_file_and_compare_hashes(file_to_download): for block in iter(lambda: f.read(65536), b""): md5.update(block) if (md5sum == md5.hexdigest()): - print "MD5 matches for %s!" % file_to_download + print("MD5 matches for %s!" % file_to_download) else: - print "MD5 mismatch for %s!" % file_to_download + print("MD5 mismatch for %s!" % file_to_download) sys.exit(1) else: - print "Cannot compare hashes for %s!" % file_to_download + print("Cannot compare hashes for %s!" % file_to_download) def download_version(version): @@ -175,16 +175,16 @@ def nacl_versions(version): for line in myfile: name, var = line.partition("=")[::2] myvars[name] = var - print "nacl-binutils commit: %s" % myvars["NACL_BINUTILS_COMMIT"] - print "nacl-gcc commit: %s" % myvars["NACL_GCC_COMMIT"] - print "nacl-newlib commit: %s" % myvars["NACL_NEWLIB_COMMIT"] + print("nacl-binutils commit: %s" % myvars["NACL_BINUTILS_COMMIT"]) + print("nacl-gcc commit: %s" % myvars["NACL_GCC_COMMIT"]) + print("nacl-newlib commit: %s" % myvars["NACL_NEWLIB_COMMIT"]) # Parse GIT_REVISIONS dict from toolchain_build.py sys.path.append(os.path.abspath(chrome_dir + "/native_client/toolchain_build")) from toolchain_build import GIT_REVISIONS - print "nacl-arm-binutils commit: %s" % GIT_REVISIONS['binutils']['rev'] - print "nacl-arm-gcc commit: %s" % GIT_REVISIONS['gcc']['rev'] + print("nacl-arm-binutils commit: %s" % GIT_REVISIONS['binutils']['rev']) + print("nacl-arm-gcc commit: %s" % GIT_REVISIONS['gcc']['rev']) def download_chrome_latest_rpm(arch): @@ -197,15 +197,15 @@ def download_chrome_latest_rpm(arch): # Let's make sure we haven't already downloaded it. if os.path.isfile("./%s" % chrome_rpm): - print "%s already exists!" % chrome_rpm + print("%s already exists!" % chrome_rpm) else: - print "Downloading %s" % path + print("Downloading %s" % path) # Perhaps look at using python-progressbar at some point? - info=urllib.urlretrieve(path, chrome_rpm, reporthook=dlProgress)[1] - urllib.urlcleanup() - print "" + info=urllib.request.urlretrieve(path, chrome_rpm, reporthook=dlProgress)[1] + urllib.request.urlcleanup() + print("") if (info["Content-Type"] != "binary/octet-stream" and info["Content-Type"] != "application/x-redhat-package-manager"): - print 'Chrome %s rpms are not on servers.' % version_string + print('Chrome %s rpms are not on servers.' % version_string) remove_file_if_exists (chrome_rpm) sys.exit(1) @@ -274,7 +274,7 @@ if __name__ == '__main__': version_string = "dev" elif (not (args.stable or args.beta or args.dev)): if (not args.version): - print 'No version specified, downloading STABLE' + print('No version specified, downloading STABLE') args.stable = True chromium_version = args.version if args.version else check_omahaproxy(version_string) @@ -284,7 +284,7 @@ if __name__ == '__main__': if args.chrome: if args.version: - print 'You cannot specify a Chrome RPM version!' + print('You cannot specify a Chrome RPM version!') sys.exit(1) latest = 'google-chrome-%s_current_i386' % version_string download_chrome_latest_rpm("i386") @@ -303,11 +303,11 @@ if __name__ == '__main__': shutil.rmtree(latest_dir) if os.path.isdir(latest_dir): - print "%s already exists, perhaps %s has already been unpacked?" % (latest_dir, latest) + print("%s already exists, perhaps %s has already been unpacked?" % (latest_dir, latest)) else: - print "Unpacking %s into %s, please wait." % (latest, latest_dir) + print("Unpacking %s into %s, please wait." % (latest, latest_dir)) if (os.system("tar -xJf %s" % latest) != 0): - print "%s is possibly corrupted, exiting." % (latest) + print("%s is possibly corrupted, exiting." % (latest)) sys.exit(1) if (args.naclvers): @@ -334,11 +334,11 @@ if __name__ == '__main__': if (args.ffmpegclean): print("Cleaning ffmpeg from proprietary things...") os.system("./clean_ffmpeg.sh %s %d" % (latest_dir, 0 if args.ffmpegarm else 1)) - print "Done!" + print("Done!") if (not args.prep): - print "Compressing cleaned tree, please wait..." + print("Compressing cleaned tree, please wait...") os.chdir(chromium_root_dir) os.system("tar --exclude=\.svn -cf - chromium-%s | xz -9 -T 0 -f > %s" % (chromium_version, chromium_clean_xz_file)) - print "Finished!" + print("Finished!") diff --git a/chromium.spec b/chromium.spec index ed674916..c03e8325 100644 --- a/chromium.spec +++ b/chromium.spec @@ -55,15 +55,15 @@ # Requires is trickier. # To generate this list, go into %%{buildroot}%%{chromium_path} and run -# for i in `find . -name "*.so"`; do NAME=`basename -s .so $i`; printf "$NAME|"; done +# for i in `find . -name "*.so" | sort`; do NAME=`basename -s .so $i`; printf "$NAME|"; done # for RHEL7, append libfontconfig to the end # make sure there is not a trailing | at the end of the list %global __provides_exclude_from %{chromium_path}/.*\\.so|%{chromium_path}/lib/.*\\.so|%{chromium_path}/lib/.*\\.so.* %if 0%{?rhel} == 7 -%global privlibs libservice|libui_accessibility_ax_mojom_blink|libmojo_mojom_bindings_shared|libcolor_space|libui_base_ime_linux|libv8|libtracing_cpp|libprotobuf_lite|librange|libui_touch_selection|libgtkui|libraster|libstub_window|libmessage_center|libv8_libplatform|libtab_count_metrics|libclient|libaura|libresource_coordinator_public_mojom_shared|libbluetooth|libipc_mojom_shared|libdevice_event_log|libcc_debug|libnet_with_v8|libcc_paint|libwm_public|libnetwork_cpp_base|libservice_manager_mojom|libaura_extra|libmojo_public_system|libpdfium|libui_base_ime_init|libmpris|libcc|libservice_manager_cpp|libblink_mojom_broadcastchannel_bindings_shared|libinterfaces_shared|libservice_manager_cpp_types|libservice_manager_mojom_shared|libwm|libbase_i18n|libnetwork_session_configurator|libwebview|libplatform_window_handler_libs|libx11_events_platform|libmojo_cpp_platform|libandroid_mojo_bindings_shared|libpublic|libmirroring_service|libmedia_session_cpp|libblink_platform|libicui18n|libwebdata_common|libgin|libdevice_gamepad|libdevice_vr_mojo_bindings|libffmpeg|libmetrics_cpp|liburl_matcher|libpolicy_proto|libshared_memory_support|libparsers|libgles2_utils|libweb_feature_mojo_bindings_mojom|libui_base_idle|libmojo_public_system_cpp|libsuid_sandbox_client|libgfx_ipc_skia|libmojo_base_shared_typemap_traits|libcapture_lib|libgl_init|libblink_common|libcc_base|libmojo_base_mojom|libtracing_mojom_shared|libgpu_ipc_service|libui_accessibility_ax_mojom|libweb_feature_mojo_bindings_mojom_shared|libgfx_switches|libmedia_session_base_cpp|libmessage_support|libvulkan_init|libonc|libgpu|libmojom_modules_shared|libnative_theme|libgcm|libvr_base|libmojo_core_embedder_internal|libuser_prefs|libweb_bluetooth_mojo_bindings_shared|libos_crypt|libbrowser_ui_views|libembedder_switches|libcontent_service_mojom_shared|libsandbox|libvulkan_x11|libdevice_vr_test_mojo_bindings|libmojo_core_ports|libblink_core|libx11_window|libmojo_mojom_bindings|libipc|libmojo_base_mojom_blink|libgl_wrapper|libprinting|libgesture_detection|libdiscardable_memory_service|libmojom_core_shared|libviz_vulkan_context_provider|libpolicy_component|libdisplay|libvr_common|libdevice_vr_test_mojo_bindings_shared|libui_accessibility_ax_mojom_shared|libresource_coordinator_public_mojom|libvulkan_wrapper|libcrcrypto|libGLESv2|libv8_libbase|libcrash_key|libchrome_features|libdiscardable_memory_common|libbindings|libfreetype_harfbuzz|libcapture_base|libmojo_core_embedder|libprefs|libdevice_features|libresource_coordinator_cpp_features|libgfx_ipc_geometry|libgfx|libui_devtools|libweb_dialogs|libkeyed_service_core|libcontent|libgeometry_skia|libdisplay_util|libservice_manager_mojom_traits|libkeycodes_x11|libipc_mojom|libmojo_base_lib|libui_base_clipboard_types|libtracing_mojom|libmanager|libmedia_webrtc|libmedia_mojo_services|libcontent_public_common_mojo_bindings_shared|libgfx_ipc|libdiscardable_memory_client|libmemory_instrumentation|libui_base_ime|libskia|libgfx_ipc_color|libshell_dialogs|libEGL|libmedia_blink|libmedia_message_center|libblink_controller|libdevice_vr_mojo_bindings_shared|libmidi|libapdu|libseccomp_bpf|libboringssl|libcolor_utils|libdbus|libproxy_config|libblink_features|libmojom_platform_shared|libshared_with_blink|libui_data_pack|libevents_x|libleveldatabase|libevents_ozone_layout|libgfx_x11|libsurface|liblearning_impl|libgamepad_mojom|libcontent_service_cpp|libui_base|libzygote|libevents|libvulkan|libGLESv2|libEGL|libcertificate_matching|libusb_shared|libbindings_base|libgfx_ipc_buffer_types|libcodec|libmojom_mhtml_load_result_shared|libstorage_common|libdevice_vr|libviz_resource_format_utils|libservice_manager_mojom_blink|libgles2|libauthenticator_test_mojo_bindings_shared|libui_base_clipboard|libgamepad_mojom_shared|libdomain_reliability|libmenu|libblink_embedded_frame_sink_mojo_bindings_shared|libwebgpu|liburl_ipc|libnet|libmedia_gpu|libservice_manager_mojom_constants_shared|libaccessibility|libservice_manager_mojom_constants|libembedder|libgamepad_mojom_blink|libcc_animation|libplatform|libdevice_base|libanimation|libgamepad_shared_typemap_traits|libwtf|libthread_linux|libui_base_x|libcloud_policy_proto_generated_compile|libsql|libhost|libextras|libchromium_sqlite3|libnetwork_cpp|libmojo_base_mojom_shared|libgeometry|libppapi_proxy|libweb_feature_mojo_bindings_mojom_blink|libcontent_common_mojo_bindings_shared|libVkICD_mock_icd|libdevice_vr_mojo_bindings_blink|libservice_manager_mojom_constants_blink|libevents_base|liburl|libresource_coordinator_public_mojom_blink|libppapi_host|libppapi_shared|libmedia|libtracing|libsandbox_services|libcontent_service_mojom|libevents_devices_x11|libcompositor|libfingerprint|libuser_manager|libstorage_browser|libbase|libkeyed_service_content|libviews|libcaptive_portal|libcbor|libviz_common|libcc_mojo_embedder|libheadless_non_renderer|libui_base_features|libsnapshot|libcommon|libnetwork_service|liblearning_common|libblink_modules|libscheduling_metrics|libperfetto|libgles2_implementation|libsessions|libdevices|libstartup_tracing|libdisplay_types|libgl_in_process_context|libui_base_ime_types|libui_message_center_cpp|libclearkeycdm|libicuuc|libfido|libfontconfig +%global privlibs libaccessibility|libandroid_mojo_bindings_shared|libanimation|libapdu|libaura_extra|libaura|libauthenticator_test_mojo_bindings_shared|libbase_i18n|libbase|libbindings_base|libbindings|libblink_common|libblink_controller|libblink_core|libblink_embedded_frame_sink_mojo_bindings_shared|libblink_features|libblink_modules|libblink_mojom_broadcastchannel_bindings_shared|libblink_platform|libbluetooth|libboringssl|libbrowser_ui_views|libcaptive_portal|libcapture_base|libcapture_lib|libcbor|libcc_animation|libcc_base|libcc_debug|libcc_mojo_embedder|libcc_paint|libcc|libcertificate_matching|libchrome_features|libchromium_sqlite3|libclient|libcloud_policy_proto_generated_compile|libcodec|libcolor_space|libcolor_utils|libcommon|libcompositor|libcontent_common_mojo_bindings_shared|libcontent_public_common_mojo_bindings_shared|libcontent_service_cpp|libcontent_service_mojom_shared|libcontent_service_mojom|libcontent_settings_features|libcontent|libcrash_key|libcrcrypto|libdbus|libdevice_base|libdevice_event_log|libdevice_features|libdevice_gamepad|libdevices|libdevice_vr_mojo_bindings_blink|libdevice_vr_mojo_bindings_shared|libdevice_vr_mojo_bindings|libdevice_vr|libdevice_vr_test_mojo_bindings_blink|libdevice_vr_test_mojo_bindings_shared|libdevice_vr_test_mojo_bindings|libdiscardable_memory_client|libdiscardable_memory_common|libdiscardable_memory_service|libdisplay|libdisplay_types|libdisplay_util|libdomain_reliability|libEGL|libembedder|libembedder_switches|libevents_base|libevents_devices_x11|libevents_ozone_layout|libevents|libevents_x|libextras|libffmpeg|libfido|libfingerprint|libfreetype_harfbuzz|libgamepad_mojom_blink|libgamepad_mojom_shared|libgamepad_mojom|libgamepad_shared_typemap_traits|libgcm|libgeometry_skia|libgeometry|libgesture_detection|libgfx_ipc_buffer_types|libgfx_ipc_color|libgfx_ipc_geometry|libgfx_ipc_skia|libgfx_ipc|libgfx|libgfx_switches|libgfx_x11|libgin|libgles2_implementation|libgles2|libgles2_utils|libGLESv2|libgl_init|libgl_in_process_context|libgl_wrapper|libgpu_ipc_service|libgpu|libgtkui|libheadless_non_renderer|libhost|libicui18n|libicuuc|libinterfaces_shared|libipc_mojom_shared|libipc_mojom|libipc|libkeycodes_x11|libkeyed_service_content|libkeyed_service_core|liblearning_common|liblearning_impl|libleveldatabase|libleveldb_proto|libmanager|libmedia_blink|libmedia_gpu|libmedia_learning_mojo_impl|libmedia_message_center|libmedia_mojo_services|libmedia_session_base_cpp|libmedia_session_cpp|libmedia|libmedia_webrtc|libmemory_instrumentation|libmenu|libmessage_center|libmessage_support|libmetrics_cpp|libmidi|libmirroring_service|libmojo_base_lib|libmojo_base_mojom_blink|libmojo_base_mojom_shared|libmojo_base_mojom|libmojo_base_shared_typemap_traits|libmojo_core_embedder_internal|libmojo_core_embedder|libmojo_core_ports|libmojo_cpp_platform|libmojom_core_shared|libmojom_mhtml_load_result_shared|libmojom_modules_shared|libmojo_mojom_bindings_shared|libmojo_mojom_bindings|libmojom_platform_shared|libmojo_public_system_cpp|libmojo_public_system|libmpris|libnative_theme|libnet|libnet_with_v8|libnetwork_cpp_base|libnetwork_cpp|libnetwork_service|libnetwork_session_configurator|libonc|libos_crypt|libparsers|libpdfium|libperfetto|libplatform|libplatform_window_handler_libs|libpolicy_component|libpolicy_proto|libppapi_host|libppapi_proxy|libppapi_shared|libprefs|libprinting|libprotobuf_lite|libproxy_config|libpublic|librange|libraster|libresource_coordinator_public_mojom_blink|libresource_coordinator_public_mojom_shared|libresource_coordinator_public_mojom|libsandbox_services|libsandbox|libscheduling_metrics|libseccomp_bpf|libservice_manager_cpp|libservice_manager_cpp_types|libservice_manager_mojom_blink|libservice_manager_mojom_constants_blink|libservice_manager_mojom_constants_shared|libservice_manager_mojom_constants|libservice_manager_mojom_shared|libservice_manager_mojom|libservice_manager_mojom_traits|libservice|libsessions|libshared_memory_support|libshared_with_blink|libshell_dialogs|libskia|libsnapshot|libsql|libstartup_tracing|libstorage_browser|libstorage_common|libstub_window|libsuid_sandbox_client|libsurface|libtab_count_metrics|libthread_linux|libtracing_cpp|libtracing_mojom_shared|libtracing_mojom|libtracing|libui_accessibility_ax_mojom_blink|libui_accessibility_ax_mojom_shared|libui_accessibility_ax_mojom|libui_base_clipboard|libui_base_clipboard_types|libui_base_features|libui_base_idle|libui_base_ime_init|libui_base_ime_linux|libui_base_ime|libui_base_ime_types|libui_base|libui_base_x|libui_data_pack|libui_devtools|libui_message_center_cpp|libui_touch_selection|liburl_ipc|liburl_matcher|liburl|libusb_shared|libuser_manager|libuser_prefs|libv8_libbase|libv8_libplatform|libv8|libviews|libviz_common|libviz_resource_format_utils|libviz_vulkan_context_provider|libVkICD_mock_icd|libvr_base|libvr_common|libvulkan_init|libvulkan_wrapper|libvulkan_x11|libweb_bluetooth_mojo_bindings_shared|libwebdata_common|libweb_dialogs|libweb_feature_mojo_bindings_mojom_blink|libweb_feature_mojo_bindings_mojom_shared|libweb_feature_mojo_bindings_mojom|libwebgpu|libwebview|libwm_public|libwm|libwtf|libx11_events_platform|libx11_window|libzygote|libEGL|libGLESv2|libvk_swiftshader|libfontconfig %else -%global privlibs libservice|libui_accessibility_ax_mojom_blink|libmojo_mojom_bindings_shared|libcolor_space|libui_base_ime_linux|libv8|libtracing_cpp|libprotobuf_lite|librange|libui_touch_selection|libgtkui|libraster|libstub_window|libmessage_center|libv8_libplatform|libtab_count_metrics|libclient|libaura|libresource_coordinator_public_mojom_shared|libbluetooth|libipc_mojom_shared|libdevice_event_log|libcc_debug|libnet_with_v8|libcc_paint|libwm_public|libnetwork_cpp_base|libservice_manager_mojom|libaura_extra|libmojo_public_system|libpdfium|libui_base_ime_init|libmpris|libcc|libservice_manager_cpp|libblink_mojom_broadcastchannel_bindings_shared|libinterfaces_shared|libservice_manager_cpp_types|libservice_manager_mojom_shared|libwm|libbase_i18n|libnetwork_session_configurator|libwebview|libplatform_window_handler_libs|libx11_events_platform|libmojo_cpp_platform|libandroid_mojo_bindings_shared|libpublic|libmirroring_service|libmedia_session_cpp|libblink_platform|libicui18n|libwebdata_common|libgin|libdevice_gamepad|libdevice_vr_mojo_bindings|libffmpeg|libmetrics_cpp|liburl_matcher|libpolicy_proto|libshared_memory_support|libparsers|libgles2_utils|libweb_feature_mojo_bindings_mojom|libui_base_idle|libmojo_public_system_cpp|libsuid_sandbox_client|libgfx_ipc_skia|libmojo_base_shared_typemap_traits|libcapture_lib|libgl_init|libblink_common|libcc_base|libmojo_base_mojom|libtracing_mojom_shared|libgpu_ipc_service|libui_accessibility_ax_mojom|libweb_feature_mojo_bindings_mojom_shared|libgfx_switches|libmedia_session_base_cpp|libmessage_support|libvulkan_init|libonc|libgpu|libmojom_modules_shared|libnative_theme|libgcm|libvr_base|libmojo_core_embedder_internal|libuser_prefs|libweb_bluetooth_mojo_bindings_shared|libos_crypt|libbrowser_ui_views|libembedder_switches|libcontent_service_mojom_shared|libsandbox|libvulkan_x11|libdevice_vr_test_mojo_bindings|libmojo_core_ports|libblink_core|libx11_window|libmojo_mojom_bindings|libipc|libmojo_base_mojom_blink|libgl_wrapper|libprinting|libgesture_detection|libdiscardable_memory_service|libmojom_core_shared|libviz_vulkan_context_provider|libpolicy_component|libdisplay|libvr_common|libdevice_vr_test_mojo_bindings_shared|libui_accessibility_ax_mojom_shared|libresource_coordinator_public_mojom|libvulkan_wrapper|libcrcrypto|libGLESv2|libv8_libbase|libcrash_key|libchrome_features|libdiscardable_memory_common|libbindings|libfreetype_harfbuzz|libcapture_base|libmojo_core_embedder|libprefs|libdevice_features|libresource_coordinator_cpp_features|libgfx_ipc_geometry|libgfx|libui_devtools|libweb_dialogs|libkeyed_service_core|libcontent|libgeometry_skia|libdisplay_util|libservice_manager_mojom_traits|libkeycodes_x11|libipc_mojom|libmojo_base_lib|libui_base_clipboard_types|libtracing_mojom|libmanager|libmedia_webrtc|libmedia_mojo_services|libcontent_public_common_mojo_bindings_shared|libgfx_ipc|libdiscardable_memory_client|libmemory_instrumentation|libui_base_ime|libskia|libgfx_ipc_color|libshell_dialogs|libEGL|libmedia_blink|libmedia_message_center|libblink_controller|libdevice_vr_mojo_bindings_shared|libmidi|libapdu|libseccomp_bpf|libboringssl|libcolor_utils|libdbus|libproxy_config|libblink_features|libmojom_platform_shared|libshared_with_blink|libui_data_pack|libevents_x|libleveldatabase|libevents_ozone_layout|libgfx_x11|libsurface|liblearning_impl|libgamepad_mojom|libcontent_service_cpp|libui_base|libzygote|libevents|libvulkan|libGLESv2|libEGL|libcertificate_matching|libusb_shared|libbindings_base|libgfx_ipc_buffer_types|libcodec|libmojom_mhtml_load_result_shared|libstorage_common|libdevice_vr|libviz_resource_format_utils|libservice_manager_mojom_blink|libgles2|libauthenticator_test_mojo_bindings_shared|libui_base_clipboard|libgamepad_mojom_shared|libdomain_reliability|libmenu|libblink_embedded_frame_sink_mojo_bindings_shared|libwebgpu|liburl_ipc|libnet|libmedia_gpu|libservice_manager_mojom_constants_shared|libaccessibility|libservice_manager_mojom_constants|libembedder|libgamepad_mojom_blink|libcc_animation|libplatform|libdevice_base|libanimation|libgamepad_shared_typemap_traits|libwtf|libthread_linux|libui_base_x|libcloud_policy_proto_generated_compile|libsql|libhost|libextras|libchromium_sqlite3|libnetwork_cpp|libmojo_base_mojom_shared|libgeometry|libppapi_proxy|libweb_feature_mojo_bindings_mojom_blink|libcontent_common_mojo_bindings_shared|libVkICD_mock_icd|libdevice_vr_mojo_bindings_blink|libservice_manager_mojom_constants_blink|libevents_base|liburl|libresource_coordinator_public_mojom_blink|libppapi_host|libppapi_shared|libmedia|libtracing|libsandbox_services|libcontent_service_mojom|libevents_devices_x11|libcompositor|libfingerprint|libuser_manager|libstorage_browser|libbase|libkeyed_service_content|libviews|libcaptive_portal|libcbor|libviz_common|libcc_mojo_embedder|libheadless_non_renderer|libui_base_features|libsnapshot|libcommon|libnetwork_service|liblearning_common|libblink_modules|libscheduling_metrics|libperfetto|libgles2_implementation|libsessions|libdevices|libstartup_tracing|libdisplay_types|libgl_in_process_context|libui_base_ime_types|libui_message_center_cpp|libclearkeycdm|libicuuc|libfido +%global privlibs libaccessibility|libandroid_mojo_bindings_shared|libanimation|libapdu|libaura_extra|libaura|libauthenticator_test_mojo_bindings_shared|libbase_i18n|libbase|libbindings_base|libbindings|libblink_common|libblink_controller|libblink_core|libblink_embedded_frame_sink_mojo_bindings_shared|libblink_features|libblink_modules|libblink_mojom_broadcastchannel_bindings_shared|libblink_platform|libbluetooth|libboringssl|libbrowser_ui_views|libcaptive_portal|libcapture_base|libcapture_lib|libcbor|libcc_animation|libcc_base|libcc_debug|libcc_mojo_embedder|libcc_paint|libcc|libcertificate_matching|libchrome_features|libchromium_sqlite3|libclient|libcloud_policy_proto_generated_compile|libcodec|libcolor_space|libcolor_utils|libcommon|libcompositor|libcontent_common_mojo_bindings_shared|libcontent_public_common_mojo_bindings_shared|libcontent_service_cpp|libcontent_service_mojom_shared|libcontent_service_mojom|libcontent_settings_features|libcontent|libcrash_key|libcrcrypto|libdbus|libdevice_base|libdevice_event_log|libdevice_features|libdevice_gamepad|libdevices|libdevice_vr_mojo_bindings_blink|libdevice_vr_mojo_bindings_shared|libdevice_vr_mojo_bindings|libdevice_vr|libdevice_vr_test_mojo_bindings_blink|libdevice_vr_test_mojo_bindings_shared|libdevice_vr_test_mojo_bindings|libdiscardable_memory_client|libdiscardable_memory_common|libdiscardable_memory_service|libdisplay|libdisplay_types|libdisplay_util|libdomain_reliability|libEGL|libembedder|libembedder_switches|libevents_base|libevents_devices_x11|libevents_ozone_layout|libevents|libevents_x|libextras|libffmpeg|libfido|libfingerprint|libfreetype_harfbuzz|libgamepad_mojom_blink|libgamepad_mojom_shared|libgamepad_mojom|libgamepad_shared_typemap_traits|libgcm|libgeometry_skia|libgeometry|libgesture_detection|libgfx_ipc_buffer_types|libgfx_ipc_color|libgfx_ipc_geometry|libgfx_ipc_skia|libgfx_ipc|libgfx|libgfx_switches|libgfx_x11|libgin|libgles2_implementation|libgles2|libgles2_utils|libGLESv2|libgl_init|libgl_in_process_context|libgl_wrapper|libgpu_ipc_service|libgpu|libgtkui|libheadless_non_renderer|libhost|libicui18n|libicuuc|libinterfaces_shared|libipc_mojom_shared|libipc_mojom|libipc|libkeycodes_x11|libkeyed_service_content|libkeyed_service_core|liblearning_common|liblearning_impl|libleveldatabase|libleveldb_proto|libmanager|libmedia_blink|libmedia_gpu|libmedia_learning_mojo_impl|libmedia_message_center|libmedia_mojo_services|libmedia_session_base_cpp|libmedia_session_cpp|libmedia|libmedia_webrtc|libmemory_instrumentation|libmenu|libmessage_center|libmessage_support|libmetrics_cpp|libmidi|libmirroring_service|libmojo_base_lib|libmojo_base_mojom_blink|libmojo_base_mojom_shared|libmojo_base_mojom|libmojo_base_shared_typemap_traits|libmojo_core_embedder_internal|libmojo_core_embedder|libmojo_core_ports|libmojo_cpp_platform|libmojom_core_shared|libmojom_mhtml_load_result_shared|libmojom_modules_shared|libmojo_mojom_bindings_shared|libmojo_mojom_bindings|libmojom_platform_shared|libmojo_public_system_cpp|libmojo_public_system|libmpris|libnative_theme|libnet|libnet_with_v8|libnetwork_cpp_base|libnetwork_cpp|libnetwork_service|libnetwork_session_configurator|libonc|libos_crypt|libparsers|libpdfium|libperfetto|libplatform|libplatform_window_handler_libs|libpolicy_component|libpolicy_proto|libppapi_host|libppapi_proxy|libppapi_shared|libprefs|libprinting|libprotobuf_lite|libproxy_config|libpublic|librange|libraster|libresource_coordinator_public_mojom_blink|libresource_coordinator_public_mojom_shared|libresource_coordinator_public_mojom|libsandbox_services|libsandbox|libscheduling_metrics|libseccomp_bpf|libservice_manager_cpp|libservice_manager_cpp_types|libservice_manager_mojom_blink|libservice_manager_mojom_constants_blink|libservice_manager_mojom_constants_shared|libservice_manager_mojom_constants|libservice_manager_mojom_shared|libservice_manager_mojom|libservice_manager_mojom_traits|libservice|libsessions|libshared_memory_support|libshared_with_blink|libshell_dialogs|libskia|libsnapshot|libsql|libstartup_tracing|libstorage_browser|libstorage_common|libstub_window|libsuid_sandbox_client|libsurface|libtab_count_metrics|libthread_linux|libtracing_cpp|libtracing_mojom_shared|libtracing_mojom|libtracing|libui_accessibility_ax_mojom_blink|libui_accessibility_ax_mojom_shared|libui_accessibility_ax_mojom|libui_base_clipboard|libui_base_clipboard_types|libui_base_features|libui_base_idle|libui_base_ime_init|libui_base_ime_linux|libui_base_ime|libui_base_ime_types|libui_base|libui_base_x|libui_data_pack|libui_devtools|libui_message_center_cpp|libui_touch_selection|liburl_ipc|liburl_matcher|liburl|libusb_shared|libuser_manager|libuser_prefs|libv8_libbase|libv8_libplatform|libv8|libviews|libviz_common|libviz_resource_format_utils|libviz_vulkan_context_provider|libVkICD_mock_icd|libvr_base|libvr_common|libvulkan_init|libvulkan_wrapper|libvulkan_x11|libweb_bluetooth_mojo_bindings_shared|libwebdata_common|libweb_dialogs|libweb_feature_mojo_bindings_mojom_blink|libweb_feature_mojo_bindings_mojom_shared|libweb_feature_mojo_bindings_mojom|libwebgpu|libwebview|libwm_public|libwm|libwtf|libx11_events_platform|libx11_window|libzygote|libEGL|libGLESv2|libvk_swiftshader %endif %global __requires_exclude ^(%{privlibs})\\.so* @@ -91,6 +91,10 @@ BuildRequires: libicu-devel >= 5.4 # 2017-06-08. %global bundlelibxml 1 +# Fedora's Python 2 stack is being removed, we use the bundled Python libraries +# This can be revisited once we upgrade to Python 3 +%global bundlepylibs 1 + # Chromium used to break on wayland, hidpi, and colors with gtk3 enabled. # Hopefully it does not anymore. %global gtk3 1 @@ -150,14 +154,14 @@ BuildRequires: libicu-devel >= 5.4 %global chromoting_client_id %nil %endif -%global majorversion 77 +%global majorversion 78 %if %{freeworld} Name: chromium%{chromium_channel}%{?freeworld:-freeworld} %else Name: chromium%{chromium_channel} %endif -Version: %{majorversion}.0.3865.120 +Version: %{majorversion}.0.3904.70 Release: 1%{?dist} Summary: A WebKit (Blink) powered web browser Url: http://www.chromium.org/Home @@ -187,44 +191,59 @@ Patch8: chromium-71.0.3578.98-widevine-r3.patch # Disable fontconfig cache magic that breaks remoting Patch9: chromium-70.0.3538.67-disable-fontconfig-cache-magic.patch # drop rsp clobber, which breaks gcc9 (thanks to Jeff Law) -Patch10: chromium-71.0.3578.98-gcc9-drop-rsp-clobber.patch +Patch10: chromium-78.0.3904.70-gcc9-drop-rsp-clobber.patch # Try to load widevine from other places Patch11: chromium-widevine-other-locations.patch # Try to fix version.py for Rawhide Patch12: chromium-71.0.3578.98-py2-bootstrap.patch # Add "Fedora" to the user agent string Patch13: chromium-77.0.3865.75-fedora-user-agent.patch - # rename function to avoid conflict with rawhide glibc "gettid()" Patch50: chromium-75.0.3770.80-grpc-gettid-fix.patch -# In GCC one can't use alignas() for exported classes -# https://chromium.googlesource.com/chromium/src.git/+/8148fd96ae04a1150a9c6012634dcd2a7335f87a -Patch51: chromium-76.0.3809.100-gcc-no-alignas-and-export.patch # Needs to be submitted.. -Patch52: chromium-76.0.3809.100-gcc-remoting-constexpr.patch +Patch51: chromium-76.0.3809.100-gcc-remoting-constexpr.patch # Needs to be submitted.. (ugly hack, needs to be added properly to GN files) -Patch53: chromium-76.0.3809.100-vtable-symbol-undefined.patch -# https://chromium.googlesource.com/chromium/src.git/+/3c9720245e440c4b7222f8348d2a2a3c25e098ae -Patch54: chromium-77.0.3865.75-certificate-transparency.patch +Patch52: chromium-78.0.3904.70-vtable-symbol-undefined.patch # https://gitweb.gentoo.org/repo/gentoo.git/tree/www-client/chromium/files/chromium-unbundle-zlib.patch -Patch55: chromium-77.0.3865.75-unbundle-zlib.patch +Patch53: chromium-78.0.3904.70-unbundle-zlib.patch # Needs to be submitted.. -Patch56: chromium-77.0.3865.75-gcc-include-memory.patch +Patch54: chromium-77.0.3865.75-gcc-include-memory.patch # https://chromium.googlesource.com/chromium/src/+/6b633c4b14850df376d5cec571699018772f358e -Patch57: chromium-77.0.3865.75-base-gcc-no-alignas.patch -# https://chromium.googlesource.com/chromium/src/+/27e25336b8316ff3ec4e464058682ed85801fd06 -Patch58: chromium-77.0.3865.75-harfbuzz-subset.patch -# https://chromium.googlesource.com/chromium/src.git/+/f08cb0022527081c078e8b96062e6c9b4fbda151 -Patch59: chromium-77.0.3865.75-gcc-abstract-class.patch -# https://chromium.googlesource.com/chromium/src/+/5baf7df7f4c5971dab552897eeef94b194650ce5 -Patch60: chromium-77.0.3865.75-missing-limits.patch -# https://chromium.googlesource.com/chromium/src/+/74138b9febd37eac0fc26b8efb110014a83a52c6 -Patch61: chromium-77.0.3865.90-linked-hash-set.patch +# https://gitweb.gentoo.org/repo/gentoo.git/tree/www-client/chromium/files/chromium-78-gcc-alignas.patch +Patch55: chromium-78.0.3904.70-base-gcc-no-alignas.patch +# https://chromium.googlesource.com/chromium/src/+/e79d9d0e06b825d2e62b38db03248c0e6ceec7e4 +Patch56: chromium-77.0.3865.120-silence-outdated-build-noise.patch +# https://chromium.googlesource.com/chromium/src/+/9c3aed099b010a75594a0efd523774c4c9a5e3d2 +Patch57: chromium-77.0.3865.120-gcc-fix-zlib-symbol-visibility.patch +# https://chromium.googlesource.com/chromium/src/+/7358ea985cb496fa7fd1a5266f915d98ed4e22e6 +Patch58: chromium-78.0.3904.70-gcc-fix-invalid-pragma.patch +# https://chromium.googlesource.com/chromium/src/+/2db67d40ef766c63a73896866a2d66e834cb9716 +Patch59: chromium-78.0.3904.70-gcc-mark-CheckOpResult-constexpr.patch +# https://chromium.googlesource.com/chromium/src/+/9662ec844017690d5fd56bf0f05ef6a540dd29c1 +Patch60: chromium-78.0.3904.70-gcc-sizet-fix.patch +# https://chromium.googlesource.com/chromium/src/+/f4c3c329588b78af63aad8b401da767242b86709 +Patch61: chromium-78.0.3904.70-gcc-DohUpgradeEntry-nonconst.patch +# https://gitweb.gentoo.org/repo/gentoo.git/tree/www-client/chromium/files/chromium-78-gcc-noexcept.patch +Patch62: chromium-78-gcc-noexcept.patch +# https://gitweb.gentoo.org/repo/gentoo.git/tree/www-client/chromium/files/chromium-78-pm-crash.patch +Patch63: chromium-78-pm-crash.patch +# https://gitweb.gentoo.org/repo/gentoo.git/tree/www-client/chromium/files/chromium-78-protobuf-export.patch +Patch64: chromium-78-protobuf-export.patch +# https://gitweb.gentoo.org/repo/gentoo.git/tree/www-client/chromium/files/chromium-78-include.patch +Patch65: chromium-78-include.patch +# https://dev.gentoo.org/~floppym/dist/chromium-78-revert-noexcept-r1.patch.gz +Patch66: chromium-78-revert-noexcept-r1.patch +# https://chromium.googlesource.com/chromium/src/+/9d01bb7f93ba4837b4430417feff845d27a66543 +Patch67: chromium-78.0.3904.70-v8-tracedreference-fix.patch +# https://chromium.googlesource.com/v8/v8/+/3677468397fa7f9fad9bbd71e9fb3120bdf67620 +Patch68: v8-implement-tracedreference.patch +# https://gitweb.gentoo.org/repo/gentoo.git/plain/www-client/chromium/files/chromium-77-clang.patch +Patch69: chromium-77-clang.patch # Use lstdc++ on EPEL7 only Patch101: chromium-75.0.3770.100-epel7-stdc++.patch # el7 only patch -Patch102: chromium-77.0.3865.90-el7-noexcept.patch +Patch102: chromium-77.0.3865.75-el7-noexcept.patch # Enable VAAPI support on Linux # NOTE: This patch will never land upstream @@ -235,6 +254,9 @@ Patch204: chromium-75.0.3770.80-vaapi-libva1-compatibility.patch # Pulseaudio changed the API a little in 12.99.1 Patch205: chromium-76.0.3809.100-pulse-api-change.patch +# Apply these patches to work around EPEL8 issues +Patch300: chromium-76.0.3809.132-rhel8-force-disable-use_gnome_keyring.patch + # Use chromium-latest.py to generate clean tarball from released build tarballs, found here: # http://build.chromium.org/buildbot/official/ # For Chromium Fedora use chromium-latest.py --stable --ffmpegclean --ffmpegarm @@ -266,8 +288,8 @@ Source15: http://download.savannah.nongnu.org/releases/freebangfont/MuktiNarrow- Source16: https://github.com/web-platform-tests/wpt/raw/master/fonts/Ahem.ttf Source17: GardinerModBug.ttf Source18: GardinerModCat.ttf -# RHEL needs newer nodejs -%if 0%{?rhel} +# RHEL 7 needs newer nodejs +%if 0%{?rhel} == 7 Source19: node-v8.9.1-linux-x64.tar.gz %endif @@ -285,9 +307,6 @@ BuildRequires: flex BuildRequires: fontconfig-devel BuildRequires: GConf2-devel BuildRequires: glib2-devel -%if 0%{?fedora} <= 27 -BuildRequires: gnome-keyring-devel -%endif BuildRequires: glibc-devel BuildRequires: gperf %if 0%{?bundleharfbuzz} @@ -315,7 +334,9 @@ BuildRequires: minizip-compat-devel BuildRequires: minizip-devel %endif # RHEL 7's nodejs is too old -%if 0%{?fedora} +%if 0%{?rhel} == 7 +# Use bundled. +%else BuildRequires: nodejs %endif BuildRequires: nss-devel >= 3.26 @@ -401,8 +422,11 @@ BuildRequires: pkgconfig(gtk+-3.0) %else BuildRequires: pkgconfig(gtk+-2.0) %endif -BuildRequires: python2-devel -%if 0%{?fedora} > 27 +BuildRequires: /usr/bin/python2 +%if 0%{?bundlepylibs} +# Using bundled bits, do nothing. +%else +%if 0%{?fedora} BuildRequires: python2-beautifulsoup4 BuildRequires: python2-beautifulsoup BuildRequires: python2-html5lib @@ -416,6 +440,8 @@ BuildRequires: python-markupsafe BuildRequires: python-ply %endif BuildRequires: python2-simplejson +BuildRequires: python2-devel +%endif %if 0%{?bundlere2} # Using bundled bits, do nothing. %else @@ -425,7 +451,9 @@ BuildRequires: re2-devel >= 20160401 BuildRequires: speech-dispatcher-devel BuildRequires: yasm BuildRequires: zlib-devel +%if 0%{?rhel} < 8 BuildRequires: pkgconfig(gnome-keyring-1) +%endif # remote desktop needs this BuildRequires: pam-devel BuildRequires: systemd @@ -433,7 +461,7 @@ BuildRequires: systemd %if %{freeworld} # dont need fonts for this %else -%if 0%{?rhel} == 7 +%if 0%{?rhel} >= 7 Source100: https://github.com/google/fonts/blob/master/apache/arimo/Arimo-Bold.ttf Source101: https://github.com/google/fonts/blob/master/apache/arimo/Arimo-BoldItalic.ttf Source102: https://github.com/google/fonts/blob/master/apache/arimo/Arimo-Italic.ttf @@ -446,12 +474,15 @@ Source108: https://github.com/google/fonts/blob/master/apache/tinos/Tinos-Bold.t Source109: https://github.com/google/fonts/blob/master/apache/tinos/Tinos-BoldItalic.ttf Source110: https://github.com/google/fonts/blob/master/apache/tinos/Tinos-Italic.ttf Source111: https://github.com/google/fonts/blob/master/apache/tinos/Tinos-Regular.ttf -Source112: https://releases.pagure.org/lohit/lohit-gurmukhi-ttf-2.91.2.tar.gz -Source113: https://noto-website-2.storage.googleapis.com/pkgs/NotoSansCJKjp-hinted.zip %else BuildRequires: google-croscore-arimo-fonts BuildRequires: google-croscore-cousine-fonts -BuildRequires: google-croscore-tinos-fonts +BuildRequires: google-croscore-tinos-fonts +%endif +%if 0%{?rhel} == 7 +Source112: https://releases.pagure.org/lohit/lohit-gurmukhi-ttf-2.91.2.tar.gz +Source113: https://noto-website-2.storage.googleapis.com/pkgs/NotoSansCJKjp-hinted.zip +%else BuildRequires: google-noto-sans-cjk-jp-fonts BuildRequires: lohit-gurmukhi-fonts %endif @@ -507,7 +538,7 @@ Provides: chromium-libs = %{version}-%{release} Obsoletes: chromium-libs <= %{version}-%{release} %endif -%if 0%{?rhel} +%if 0%{?rhel} == 7 ExclusiveArch: x86_64 i686 %else ExclusiveArch: x86_64 i686 aarch64 @@ -722,17 +753,25 @@ udev. # Short term fixes (usually gcc and backports) %patch50 -p1 -b .gettid-fix -%patch51 -p1 -b .gcc-no-alignas-and-export -%patch52 -p1 -b .gcc-remoting-constexpr -%patch53 -p1 -b .vtable-symbol-undefined -%patch54 -p1 -b .certificate-transparency -%patch55 -p1 -b .unbundle-zlib -%patch56 -p1 -b .gcc-include-memory -%patch57 -p1 -b .base-gcc-no-alignas -%patch58 -p1 -b .harfbuzz-subset -%patch59 -p1 -b .gcc-abstract-class -%patch60 -p1 -b .missing-limits -%patch61 -p1 -b .linked-hash-set +%patch51 -p1 -b .gcc-remoting-constexpr +%patch52 -p1 -b .vtable-symbol-undefined +%patch53 -p1 -b .unbundle-zlib +%patch54 -p1 -b .gcc-include-memory +%patch55 -p1 -b .base-gcc-no-alignas +%patch56 -p1 -b .silence-outdated-build-noise +%patch57 -p1 -b .gcc-fix-zlib-symbol-visibility +%patch58 -p1 -b .gcc-invalid-pragma +%patch59 -p1 -b .gcc-mark-CheckOpResult-constexpr +%patch60 -p1 -b .gcc-sizet +%patch61 -p1 -b .gcc-DohUpgradeEntry-nonconst +%patch62 -p1 -b .gcc-v8-noexcept +%patch63 -p1 -b .pm-crash +%patch64 -p1 -b .protobuf-export +%patch65 -p1 -b .missing-includes +%patch66 -p1 -b .gentoo-revert-noexcept +%patch67 -p1 -b .implement-TraceWrapperV8Reference-without-destructor +%patch68 -p1 -b .v8-implement-tracedreference +%patch69 -p1 -b .clang-supports-location-builtins # Fedora branded user agent %if 0%{?fedora} @@ -758,6 +797,10 @@ udev. %patch205 -p1 -b .pulseaudioapichange %endif +%if 0%{?rhel} == 8 +%patch300 -p1 -b .disblegnomekeyring +%endif + # Change shebang in all relevant files in this directory and all subdirectories # See `man find` for how the `-exec command {} +` syntax works find -type f -exec sed -iE '1s=^#! */usr/bin/\(python\|env python\)[23]\?=#!%{__python2}=' {} + @@ -788,7 +831,7 @@ rm -rf MuktiNarrow0.94 cp %{SOURCE16} . cp %{SOURCE17} . cp %{SOURCE18} . -%if 0%{?rhel} == 7 +%if 0%{?rhel} >= 7 cp %{SOURCE100} . cp %{SOURCE101} . cp %{SOURCE102} . @@ -801,14 +844,17 @@ cp %{SOURCE108} . cp %{SOURCE109} . cp %{SOURCE110} . cp %{SOURCE111} . +%else +cp -a /usr/share/fonts/google-croscore/Arimo-*.ttf . +cp -a /usr/share/fonts/google-croscore/Cousine-*.ttf . +cp -a /usr/share/fonts/google-croscore/Tinos-*.ttf . +%endif +%if 0%{?rhel} == 7 tar xf %{SOURCE112} mv lohit-gurmukhi-ttf-2.91.2/Lohit-Gurmukhi.ttf . rm -rf lohit-gurmukhi-ttf-2.91.2 unzip %{SOURCE113} %else -cp -a /usr/share/fonts/google-croscore/Arimo-*.ttf . -cp -a /usr/share/fonts/google-croscore/Cousine-*.ttf . -cp -a /usr/share/fonts/google-croscore/Tinos-*.ttf . cp -a /usr/share/fonts/lohit-gurmukhi/Lohit-Gurmukhi.ttf . cp -a /usr/share/fonts/google-noto-cjk/NotoSansCJKjp-Regular.otf . %endif @@ -840,6 +886,9 @@ CHROMIUM_CORE_GN_DEFINES+=' target_cpu="arm64"' %if %{?use_jumbo} CHROMIUM_CORE_GN_DEFINES+=' use_jumbo_build=true jumbo_file_merge_limit=8' %endif +%if 0%{?rhel} == 8 +CHROMIUM_CORE_GN_DEFINES+=' use_gnome_keyring=false use_glib=true' +%endif export CHROMIUM_CORE_GN_DEFINES CHROMIUM_BROWSER_GN_DEFINES="" @@ -871,7 +920,7 @@ CHROMIUM_HEADLESS_GN_DEFINES+=' use_cups=false use_dbus=false use_gio=false use_ CHROMIUM_HEADLESS_GN_DEFINES+=' use_pulseaudio=false use_udev=false' export CHROMIUM_HEADLESS_GN_DEFINES -%if 0%{?rhel} +%if 0%{?rhel} == 7 pushd third_party/node/linux tar xf %{SOURCE19} mv node-v8.9.1-linux-x64 node-linux-x64 @@ -885,7 +934,7 @@ ln -s %{_bindir}/node third_party/node/linux/node-linux-x64/bin/node # Gentoo's Chromium ebuild) are the libraries that needs to be preserved. build/linux/unbundle/remove_bundled_libraries.py \ 'base/third_party/cityhash' \ - 'base/third_party/dmg_fp' \ + 'base/third_party/double_conversion' \ 'base/third_party/dynamic_annotations' \ 'base/third_party/icu' \ 'base/third_party/libevent' \ @@ -941,6 +990,7 @@ build/linux/unbundle/remove_bundled_libraries.py \ 'third_party/catapult/third_party/six' \ 'third_party/catapult/tracing/third_party/d3' \ 'third_party/catapult/tracing/third_party/gl-matrix' \ + 'third_party/catapult/tracing/third_party/jpeg-js' \ 'third_party/catapult/tracing/third_party/jszip' \ 'third_party/catapult/tracing/third_party/mannwhitneyu' \ 'third_party/catapult/tracing/third_party/oboe' \ @@ -955,6 +1005,7 @@ build/linux/unbundle/remove_bundled_libraries.py \ 'third_party/cros_system_api' \ 'third_party/dav1d' \ 'third_party/dawn' \ + 'third_party/depot_tools' \ 'third_party/devscripts' \ 'third_party/dom_distiller_js' \ 'third_party/emoji-segmenter' \ @@ -1008,7 +1059,7 @@ build/linux/unbundle/remove_bundled_libraries.py \ 'third_party/libyuv' \ 'third_party/lss' \ 'third_party/lzma_sdk' \ -%if 0 +%if 0%{?bundlepylibs} 'third_party/markupsafe' \ %endif 'third_party/mesa' \ @@ -1039,6 +1090,7 @@ build/linux/unbundle/remove_bundled_libraries.py \ 'third_party/pffft' \ 'third_party/ply' \ 'third_party/polymer' \ + 'third_party/private-join-and-compute' \ 'third_party/protobuf' \ 'third_party/protobuf/third_party/six' \ 'third_party/pyjson5' \ @@ -1099,10 +1151,12 @@ build/linux/unbundle/remove_bundled_libraries.py \ 'v8/third_party/inspector_protocol' \ --do-remove +%if ! 0%{?bundlepylibs} # Look, I don't know. This package is spit and chewing gum. Sorry. rm -rf third_party/markupsafe ln -s %{python2_sitearch}/markupsafe third_party/markupsafe # We should look on removing other python2 packages as well i.e. ply +%endif # Fix hardcoded path in remoting code sed -i 's|/opt/google/chrome-remote-desktop|%{crd_path}|g' remoting/host/setup/daemon_controller_delegate_linux.cc @@ -1635,9 +1689,27 @@ getent group chrome-remote-desktop >/dev/null || groupadd -r chrome-remote-deskt %changelog +* Wed Oct 23 2019 Tom Callaway - 78.0.3904.80-1 +- update to 78.0.3904.80 + +* Wed Oct 16 2019 Tom Callaway - 77.0.3865.120-4 +- upstream fix for zlib symbol exports with gcc + +* Wed Oct 16 2019 Tom Callaway - 77.0.3865.120-3 +- silence outdated build noise (bz1745745) + +* Tue Oct 15 2019 Tom Callaway - 77.0.3865.120-2 +- fix node handling for EPEL-8 + * Mon Oct 14 2019 Tomas Popela - 77.0.3865.120-1 - Update to 77.0.3865.120 +* Thu Oct 10 2019 Tom Callaway - 77.0.3865.90-4 +- enable aarch64 for EPEL-8 + +* Wed Oct 9 2019 Tom Callaway - 77.0.3865.90-3 +- spec cleanups and changes to make EPEL8 try to build + * Mon Sep 23 2019 Tomas Popela - 77.0.3865.90-2 - Fix the icon - Remove quite a few of downstream patches diff --git a/package.cfg b/package.cfg new file mode 100644 index 00000000..66ea79dd --- /dev/null +++ b/package.cfg @@ -0,0 +1,2 @@ +[koji] +targets = epel8 epel8-playground \ No newline at end of file diff --git a/sources b/sources index 978a610a..6e05be22 100644 --- a/sources +++ b/sources @@ -17,4 +17,4 @@ SHA512 (Tinos-Italic.ttf) = d4f4f096110ef98a781a2a0e0d319317e5f84e650fe6f4d4f6b0 SHA512 (Tinos-Regular.ttf) = 58085c5dac6d067d60ba2ab3220c4a0cc1efcf279cadfcfb8746a5e5fa1a6f6daa62750dc2051b3b2d8a51b4d2e9bb0f66594caf2253c0870ed9c7286fa45e8f SHA512 (Ahem.ttf) = aeb64b10ab9c87860714cb60b4900254b13dc52c51319256a1a3722c882026ab7c616bf628fbc2fe14e38a6003f3a481af60b52a7ed62071d28ddaf428e4e3fd SHA512 (node-v8.9.1-linux-x64.tar.gz) = a707fd4567041c56e7f9d415e505e3fa650627f31def7fefdd7ec50f9e7066bb33332b67f479e1159d85e1105a7e6d034aad7429f4f3d034c9161170d7e0b844 -SHA512 (chromium-77.0.3865.120-clean.tar.xz) = 018702b53bafeb5fe8a297b8efb4805419555acb80a22b9f5f5fe2a3484f838f6ffa06655229466aca5a9de7f8b0497b9d387da4a1ba2dbc7c62ec3d1d0ffbb9 +SHA512 (chromium-78.0.3904.70-clean.tar.xz) = f702bc3c084a69adc81f47300d00f0b8cf46ee721dbb4986bfc5ba7fc95129172d021da0514350fe77591a209ec050307eead8e9bf309b70e46eb26d29d88509 diff --git a/v8-implement-tracedreference.patch b/v8-implement-tracedreference.patch new file mode 100644 index 00000000..7dc74877 --- /dev/null +++ b/v8-implement-tracedreference.patch @@ -0,0 +1,796 @@ +diff -up chromium-78.0.3904.70/v8/include/v8.h.implement-tracedreference chromium-78.0.3904.70/v8/include/v8.h +--- chromium-78.0.3904.70/v8/include/v8.h.implement-tracedreference 2019-10-24 08:58:26.185640117 -0400 ++++ chromium-78.0.3904.70/v8/include/v8.h 2019-10-24 09:18:33.719546481 -0400 +@@ -96,6 +96,10 @@ template + class Global; + template + class TracedGlobal; ++template ++class TracedReference; ++template ++class TracedReferenceBase; + template class PersistentValueMap; + template + class PersistentValueMapBase; +@@ -281,7 +285,8 @@ class Local { + V8_INLINE static Local New(Isolate* isolate, Local that); + V8_INLINE static Local New(Isolate* isolate, + const PersistentBase& that); +- V8_INLINE static Local New(Isolate* isolate, const TracedGlobal& that); ++ V8_INLINE static Local New(Isolate* isolate, ++ const TracedReferenceBase& that); + + private: + friend class Utils; +@@ -311,7 +316,13 @@ class Local { + template + friend class ReturnValue; + template ++ friend class Traced; ++ template + friend class TracedGlobal; ++ template ++ friend class TracedReferenceBase; ++ template ++ friend class TracedReference; + + explicit V8_INLINE Local(T* that) : val_(that) {} + V8_INLINE static Local New(Isolate* isolate, T* that); +@@ -792,22 +803,10 @@ template + using UniquePersistent = Global; + + /** +- * Trait specifying behavior of |TracedGlobal|. ++ * Deprecated. Use |TracedReference| instead. + */ + template +-struct TracedGlobalTrait { +- /** +- * Specifies whether |TracedGlobal| should clear its handle on destruction. +- * +- * V8 will *not* clear the embedder-side memory of the handle. The embedder is +- * expected to report all |TracedGlobal| handles through +- * |EmbedderHeapTracer| upon garabge collection. +- * +- * See |EmbedderHeapTracer::IsRootForNonTracingGC| for handling with +- * non-tracing GCs in V8. +- */ +- static constexpr bool kRequiresExplicitDestruction = true; +-}; ++struct TracedGlobalTrait {}; + + /** + * A traced handle with copy and move semantics. The handle is to be used +@@ -820,15 +819,131 @@ struct TracedGlobalTrait { + * |v8::EmbedderHeapTracer::IsRootForNonTracingGC()| whether the handle should + * be treated as root or not. + * +- * For destruction semantics see |TracedGlobalTrait|. ++ * Note that the base class cannot be instantiated itself. Choose from ++ * - TracedGlobal ++ * - TracedReference + */ + template +-class TracedGlobal { ++class TracedReferenceBase { + public: + /** ++ * Returns true if this TracedReferenceBase is empty, i.e., has not been ++ * assigned an object. ++ */ ++ bool IsEmpty() const { return val_ == nullptr; } ++ ++ /** ++ * If non-empty, destroy the underlying storage cell. |IsEmpty| will return ++ * true after this call. ++ */ ++ V8_INLINE void Reset(); ++ ++ /** ++ * Construct a Local from this handle. ++ */ ++ Local Get(Isolate* isolate) const { return Local::New(isolate, *this); } ++ ++ template ++ V8_INLINE bool operator==(const TracedReferenceBase& that) const { ++ internal::Address* a = reinterpret_cast(val_); ++ internal::Address* b = reinterpret_cast(that.val_); ++ if (a == nullptr) return b == nullptr; ++ if (b == nullptr) return false; ++ return *a == *b; ++ } ++ ++ template ++ V8_INLINE bool operator==(const Local& that) const { ++ internal::Address* a = reinterpret_cast(val_); ++ internal::Address* b = reinterpret_cast(that.val_); ++ if (a == nullptr) return b == nullptr; ++ if (b == nullptr) return false; ++ return *a == *b; ++ } ++ ++ template ++ V8_INLINE bool operator!=(const TracedReferenceBase& that) const { ++ return !operator==(that); ++ } ++ ++ template ++ V8_INLINE bool operator!=(const Local& that) const { ++ return !operator==(that); ++ } ++ ++ /** ++ * Assigns a wrapper class ID to the handle. ++ */ ++ V8_INLINE void SetWrapperClassId(uint16_t class_id); ++ ++ /** ++ * Returns the class ID previously assigned to this handle or 0 if no class ID ++ * was previously assigned. ++ */ ++ V8_INLINE uint16_t WrapperClassId() const; ++ ++ /** ++ * Adds a finalization callback to the handle. The type of this callback is ++ * similar to WeakCallbackType::kInternalFields, i.e., it will pass the ++ * parameter and the first two internal fields of the object. ++ * ++ * The callback is then supposed to reset the handle in the callback. No ++ * further V8 API may be called in this callback. In case additional work ++ * involving V8 needs to be done, a second callback can be scheduled using ++ * WeakCallbackInfo::SetSecondPassCallback. ++ */ ++ V8_INLINE void SetFinalizationCallback( ++ void* parameter, WeakCallbackInfo::Callback callback); ++ ++ template ++ V8_INLINE TracedReferenceBase& As() const { ++ return reinterpret_cast&>( ++ const_cast&>(*this)); ++ } ++ ++ private: ++ enum DestructionMode { kWithDestructor, kWithoutDestructor }; ++ ++ /** ++ * An empty TracedReferenceBase without storage cell. ++ */ ++ TracedReferenceBase() = default; ++ ++ V8_INLINE static T* New(Isolate* isolate, T* that, void* slot, ++ DestructionMode destruction_mode); ++ ++ T* val_ = nullptr; ++ ++ friend class EmbedderHeapTracer; ++ template ++ friend class Local; ++ friend class Object; ++ template ++ friend class TracedGlobal; ++ template ++ friend class TracedReference; ++ template ++ friend class ReturnValue; ++}; ++ ++/** ++ * A traced handle with destructor that clears the handle. For more details see ++ * TracedReferenceBase. ++ */ ++template ++class TracedGlobal : public TracedReferenceBase { ++ public: ++ using TracedReferenceBase::Reset; ++ ++ /** ++ * Destructor resetting the handle. ++ */ ++ ~TracedGlobal() { this->Reset(); } ++ ++ /** + * An empty TracedGlobal without storage cell. + */ +- TracedGlobal() = default; ++ TracedGlobal() : TracedReferenceBase() {} + + /** + * Construct a TracedGlobal from a Local. +@@ -837,8 +952,9 @@ class TracedGlobal { + * pointing to the same object. + */ + template +- TracedGlobal(Isolate* isolate, Local that) +- : val_(New(isolate, *that, &val_)) { ++ TracedGlobal(Isolate* isolate, Local that) : TracedReferenceBase() { ++ this->val_ = this->New(isolate, that.val_, &this->val_, ++ TracedReferenceBase::kWithDestructor); + TYPE_CHECK(T, S); + } + +@@ -905,121 +1021,126 @@ class TracedGlobal { + V8_INLINE TracedGlobal& operator=(const TracedGlobal& rhs); + + /** +- * Returns true if this TracedGlobal is empty, i.e., has not been assigned an +- * object. +- */ +- bool IsEmpty() const { return val_ == nullptr; } +- +- /** +- * If non-empty, destroy the underlying storage cell. |IsEmpty| will return +- * true after this call. +- */ +- V8_INLINE void Reset(); +- +- /** + * If non-empty, destroy the underlying storage cell and create a new one with + * the contents of other if other is non empty + */ + template + V8_INLINE void Reset(Isolate* isolate, const Local& other); + +- /** +- * Construct a Local from this handle. +- */ +- Local Get(Isolate* isolate) const { return Local::New(isolate, *this); } +- + template + V8_INLINE TracedGlobal& As() const { + return reinterpret_cast&>( + const_cast&>(*this)); + } ++}; + +- template +- V8_INLINE bool operator==(const TracedGlobal& that) const { +- internal::Address* a = reinterpret_cast(**this); +- internal::Address* b = reinterpret_cast(*that); +- if (a == nullptr) return b == nullptr; +- if (b == nullptr) return false; +- return *a == *b; +- } ++/** ++ * A traced handle without destructor that clears the handle. The embedder needs ++ * to ensure that the handle is not accessed once the V8 object has been ++ * reclaimed. This can happen when the handle is not passed through the ++ * EmbedderHeapTracer. For more details see TracedReferenceBase. ++ */ ++template ++class TracedReference : public TracedReferenceBase { ++ public: ++ using TracedReferenceBase::Reset; ++ ++ /** ++ * An empty TracedReference without storage cell. ++ */ ++ TracedReference() : TracedReferenceBase() {} + ++ /** ++ * Construct a TracedReference from a Local. ++ * ++ * When the Local is non-empty, a new storage cell is created ++ * pointing to the same object. ++ */ + template +- V8_INLINE bool operator==(const Local& that) const { +- internal::Address* a = reinterpret_cast(**this); +- internal::Address* b = reinterpret_cast(*that); +- if (a == nullptr) return b == nullptr; +- if (b == nullptr) return false; +- return *a == *b; ++ TracedReference(Isolate* isolate, Local that) : TracedReferenceBase() { ++ this->val_ = this->New(isolate, that.val_, &this->val_, ++ TracedReferenceBase::kWithoutDestructor); ++ TYPE_CHECK(T, S); + } + +- template +- V8_INLINE bool operator!=(const TracedGlobal& that) const { +- return !operator==(that); ++ /** ++ * Move constructor initializing TracedReference from an ++ * existing one. ++ */ ++ V8_INLINE TracedReference(TracedReference&& other) { ++ // Forward to operator=. ++ *this = std::move(other); + } + +- template +- V8_INLINE bool operator!=(const Local& that) const { +- return !operator==(that); ++ /** ++ * Move constructor initializing TracedReference from an ++ * existing one. ++ */ ++ template ++ V8_INLINE TracedReference(TracedReference&& other) { ++ // Forward to operator=. ++ *this = std::move(other); + } + + /** +- * Assigns a wrapper class ID to the handle. ++ * Copy constructor initializing TracedReference from an ++ * existing one. + */ +- V8_INLINE void SetWrapperClassId(uint16_t class_id); ++ V8_INLINE TracedReference(const TracedReference& other) { ++ // Forward to operator=; ++ *this = other; ++ } + + /** +- * Returns the class ID previously assigned to this handle or 0 if no class ID +- * was previously assigned. ++ * Copy constructor initializing TracedReference from an ++ * existing one. + */ +- V8_INLINE uint16_t WrapperClassId() const; ++ template ++ V8_INLINE TracedReference(const TracedReference& other) { ++ // Forward to operator=; ++ *this = other; ++ } + + /** +- * Adds a finalization callback to the handle. The type of this callback is +- * similar to WeakCallbackType::kInternalFields, i.e., it will pass the +- * parameter and the first two internal fields of the object. +- * +- * The callback is then supposed to reset the handle in the callback. No +- * further V8 API may be called in this callback. In case additional work +- * involving V8 needs to be done, a second callback can be scheduled using +- * WeakCallbackInfo::SetSecondPassCallback. ++ * Move assignment operator initializing TracedGlobal from an existing one. + */ +- V8_INLINE void SetFinalizationCallback( +- void* parameter, WeakCallbackInfo::Callback callback); ++ V8_INLINE TracedReference& operator=(TracedReference&& rhs); + +- private: +- // Wrapping type used when clearing on destruction is required. +- struct WrappedForDestruction { +- T* value; +- +- explicit WrappedForDestruction(T* val) : value(val) {} +- ~WrappedForDestruction(); +- operator T*() const { return value; } +- T* operator*() const { return value; } +- T* operator->() const { return value; } +- WrappedForDestruction& operator=(const WrappedForDestruction& other) { +- value = other.value; +- return *this; +- } +- WrappedForDestruction& operator=(T* val) { +- value = val; +- return *this; +- } +- }; ++ /** ++ * Move assignment operator initializing TracedGlobal from an existing one. ++ */ ++ template ++ V8_INLINE TracedReference& operator=(TracedReference&& rhs); + +- V8_INLINE static T* New(Isolate* isolate, T* that, void* slot); ++ /** ++ * Copy assignment operator initializing TracedGlobal from an existing one. ++ * ++ * Note: Prohibited when |other| has a finalization callback set through ++ * |SetFinalizationCallback|. ++ */ ++ V8_INLINE TracedReference& operator=(const TracedReference& rhs); + +- T* operator*() const { return this->val_; } ++ /** ++ * Copy assignment operator initializing TracedGlobal from an existing one. ++ * ++ * Note: Prohibited when |other| has a finalization callback set through ++ * |SetFinalizationCallback|. ++ */ ++ template ++ V8_INLINE TracedReference& operator=(const TracedReference& rhs); + +- typename std::conditional< +- TracedGlobalTrait>::kRequiresExplicitDestruction, +- WrappedForDestruction, T*>::type val_{nullptr}; ++ /** ++ * If non-empty, destroy the underlying storage cell and create a new one with ++ * the contents of other if other is non empty ++ */ ++ template ++ V8_INLINE void Reset(Isolate* isolate, const Local& other); + +- friend class EmbedderHeapTracer; +- template +- friend class Local; +- friend class Object; +- template +- friend class ReturnValue; ++ template ++ V8_INLINE TracedReference& As() const { ++ return reinterpret_cast&>( ++ const_cast&>(*this)); ++ } + }; + + /** +@@ -3640,8 +3761,9 @@ class V8_EXPORT Object : public Value { + return object.val_->InternalFieldCount(); + } + +- /** Same as above, but works for TracedGlobal. */ +- V8_INLINE static int InternalFieldCount(const TracedGlobal& object) { ++ /** Same as above, but works for TracedReferenceBase. */ ++ V8_INLINE static int InternalFieldCount( ++ const TracedReferenceBase& object) { + return object.val_->InternalFieldCount(); + } + +@@ -3666,7 +3788,7 @@ class V8_EXPORT Object : public Value { + + /** Same as above, but works for TracedGlobal. */ + V8_INLINE static void* GetAlignedPointerFromInternalField( +- const TracedGlobal& object, int index) { ++ const TracedReferenceBase& object, int index) { + return object.val_->GetAlignedPointerFromInternalField(index); + } + +@@ -3956,7 +4078,7 @@ class ReturnValue { + template + V8_INLINE void Set(const Global& handle); + template +- V8_INLINE void Set(const TracedGlobal& handle); ++ V8_INLINE void Set(const TracedReferenceBase& handle); + template + V8_INLINE void Set(const Local handle); + // Fast primitive setters +@@ -7376,7 +7498,8 @@ class V8_EXPORT EmbedderHeapTracer { + class V8_EXPORT TracedGlobalHandleVisitor { + public: + virtual ~TracedGlobalHandleVisitor() = default; +- virtual void VisitTracedGlobalHandle(const TracedGlobal& value) = 0; ++ virtual void VisitTracedGlobalHandle(const TracedGlobal& handle) {} ++ virtual void VisitTracedReference(const TracedReference& handle) {} + }; + + /** +@@ -7414,7 +7537,7 @@ class V8_EXPORT EmbedderHeapTracer { + virtual void RegisterV8References( + const std::vector >& embedder_fields) = 0; + +- void RegisterEmbedderReference(const TracedGlobal& ref); ++ void RegisterEmbedderReference(const TracedReferenceBase& ref); + + /** + * Called at the beginning of a GC cycle. +@@ -7475,32 +7598,35 @@ class V8_EXPORT EmbedderHeapTracer { + * + * If this returns false, then V8 may decide that the object referred to by + * such a handle is reclaimed. In that case: +- * - No action is required if handles are used with destructors. +- * - When run without destructors (by specializing +- * |TracedGlobalTrait::kRequiresExplicitDestruction|) V8 calls +- * |ResetHandleInNonTracingGC|. +- * +- * Note that the |handle| is different from the |TracedGlobal| handle that +- * the embedder holds for retaining the object. The embedder may use +- * |TracedGlobal::WrapperClassId()| to distinguish cases where it wants +- * handles to be treated as roots from not being treated as roots. ++ * - No action is required if handles are used with destructors, i.e., by just ++ * using |TracedGlobal|. ++ * - When run without destructors, i.e., by using ++ * |TracedReference|, V8 calls |ResetHandleInNonTracingGC|. ++ * ++ * Note that the |handle| is different from the handle that the embedder holds ++ * for retaining the object. The embedder may use |WrapperClassId()| to ++ * distinguish cases where it wants handles to be treated as roots from not ++ * being treated as roots. + */ + virtual bool IsRootForNonTracingGC( +- const v8::TracedGlobal& handle) { +- return true; +- } ++ const v8::TracedReference& handle); ++ virtual bool IsRootForNonTracingGC(const v8::TracedGlobal& handle); + + /** + * Used in combination with |IsRootForNonTracingGC|. Called by V8 when an + * object that is backed by a handle is reclaimed by a non-tracing garbage + * collection. It is up to the embedder to reset the original handle. + * +- * Note that the |handle| is different from the |TracedGlobal| handle that +- * the embedder holds for retaining the object. It is up to the embedder to +- * find the orignal |TracedGlobal| handle via the object or class id. ++ * Note that the |handle| is different from the handle that the embedder holds ++ * for retaining the object. It is up to the embedder to find the original ++ * handle via the object or class id. + */ + virtual void ResetHandleInNonTracingGC( +- const v8::TracedGlobal& handle) {} ++ const v8::TracedReference& handle); ++ V8_DEPRECATE_SOON( ++ "Use TracedReference version when not requiring destructors.", ++ virtual void ResetHandleInNonTracingGC( ++ const v8::TracedGlobal& handle)); + + /* + * Called by the embedder to immediately perform a full garbage collection. +@@ -9103,8 +9229,12 @@ class V8_EXPORT V8 { + template + friend class Maybe; + template ++ friend class TracedReferenceBase; ++ template + friend class TracedGlobal; + template ++ friend class TracedReference; ++ template + friend class WeakCallbackInfo; + template friend class Eternal; + template friend class PersistentBase; +@@ -9975,7 +10105,7 @@ Local Local::New(Isolate* isolate, + } + + template +-Local Local::New(Isolate* isolate, const TracedGlobal& that) { ++Local Local::New(Isolate* isolate, const TracedReferenceBase& that) { + return New(isolate, that.val_); + } + +@@ -10156,26 +10286,20 @@ Global& Global::operator=(Global +-TracedGlobal::WrappedForDestruction::~WrappedForDestruction() { +- if (value == nullptr) return; +- V8::DisposeTracedGlobal(reinterpret_cast(value)); +- value = nullptr; +-} +- +-template +-T* TracedGlobal::New(Isolate* isolate, T* that, void* slot) { ++T* TracedReferenceBase::New(Isolate* isolate, T* that, void* slot, ++ DestructionMode destruction_mode) { + if (that == nullptr) return nullptr; + internal::Address* p = reinterpret_cast(that); + return reinterpret_cast(V8::GlobalizeTracedReference( + reinterpret_cast(isolate), p, + reinterpret_cast(slot), +- TracedGlobalTrait>::kRequiresExplicitDestruction)); ++ destruction_mode == kWithDestructor)); + } + + template +-void TracedGlobal::Reset() { ++void TracedReferenceBase::Reset() { + if (IsEmpty()) return; +- V8::DisposeTracedGlobal(reinterpret_cast(**this)); ++ V8::DisposeTracedGlobal(reinterpret_cast(val_)); + val_ = nullptr; + } + +@@ -10185,7 +10309,8 @@ void TracedGlobal::Reset(Isolate* iso + TYPE_CHECK(T, S); + Reset(); + if (other.IsEmpty()) return; +- this->val_ = New(isolate, other.val_, &val_); ++ this->val_ = this->New(isolate, other.val_, &this->val_, ++ TracedReferenceBase::kWithDestructor); + } + + template +@@ -10233,28 +10358,83 @@ TracedGlobal& TracedGlobal::operat + } + + template +-void TracedGlobal::SetWrapperClassId(uint16_t class_id) { ++template ++void TracedReference::Reset(Isolate* isolate, const Local& other) { ++ TYPE_CHECK(T, S); ++ Reset(); ++ if (other.IsEmpty()) return; ++ this->val_ = this->New(isolate, other.val_, &this->val_, ++ TracedReferenceBase::kWithoutDestructor); ++} ++ ++template ++template ++TracedReference& TracedReference::operator=(TracedReference&& rhs) { ++ TYPE_CHECK(T, S); ++ *this = std::move(rhs.template As()); ++ return *this; ++} ++ ++template ++template ++TracedReference& TracedReference::operator=( ++ const TracedReference& rhs) { ++ TYPE_CHECK(T, S); ++ *this = rhs.template As(); ++ return *this; ++} ++ ++template ++TracedReference& TracedReference::operator=(TracedReference&& rhs) { ++ if (this != &rhs) { ++ this->Reset(); ++ if (rhs.val_ != nullptr) { ++ this->val_ = rhs.val_; ++ V8::MoveTracedGlobalReference( ++ reinterpret_cast(&rhs.val_), ++ reinterpret_cast(&this->val_)); ++ rhs.val_ = nullptr; ++ } ++ } ++ return *this; ++} ++ ++template ++TracedReference& TracedReference::operator=(const TracedReference& rhs) { ++ if (this != &rhs) { ++ this->Reset(); ++ if (rhs.val_ != nullptr) { ++ V8::CopyTracedGlobalReference( ++ reinterpret_cast(&rhs.val_), ++ reinterpret_cast(&this->val_)); ++ } ++ } ++ return *this; ++} ++ ++template ++void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) { + typedef internal::Internals I; + if (IsEmpty()) return; +- internal::Address* obj = reinterpret_cast(**this); ++ internal::Address* obj = reinterpret_cast(val_); + uint8_t* addr = reinterpret_cast(obj) + I::kNodeClassIdOffset; + *reinterpret_cast(addr) = class_id; + } + + template +-uint16_t TracedGlobal::WrapperClassId() const { ++uint16_t TracedReferenceBase::WrapperClassId() const { + typedef internal::Internals I; + if (IsEmpty()) return 0; +- internal::Address* obj = reinterpret_cast(**this); ++ internal::Address* obj = reinterpret_cast(val_); + uint8_t* addr = reinterpret_cast(obj) + I::kNodeClassIdOffset; + return *reinterpret_cast(addr); + } + + template +-void TracedGlobal::SetFinalizationCallback( ++void TracedReferenceBase::SetFinalizationCallback( + void* parameter, typename WeakCallbackInfo::Callback callback) { +- V8::SetFinalizationCallbackTraced( +- reinterpret_cast(**this), parameter, callback); ++ V8::SetFinalizationCallbackTraced(reinterpret_cast(val_), ++ parameter, callback); + } + + template +@@ -10273,12 +10453,12 @@ void ReturnValue::Set(const Global + + template + template +-void ReturnValue::Set(const TracedGlobal& handle) { ++void ReturnValue::Set(const TracedReferenceBase& handle) { + TYPE_CHECK(T, S); + if (V8_UNLIKELY(handle.IsEmpty())) { + *value_ = GetDefaultValue(); + } else { +- *value_ = *reinterpret_cast(*handle); ++ *value_ = *reinterpret_cast(handle.val_); + } + } + +diff -up chromium-78.0.3904.70/v8/src/api/api.cc.implement-tracedreference chromium-78.0.3904.70/v8/src/api/api.cc +--- chromium-78.0.3904.70/v8/src/api/api.cc.implement-tracedreference 2019-10-24 09:18:56.712105100 -0400 ++++ chromium-78.0.3904.70/v8/src/api/api.cc 2019-10-24 09:20:17.428555637 -0400 +@@ -10346,11 +10346,12 @@ void EmbedderHeapTracer::DecreaseAllocat + } + + void EmbedderHeapTracer::RegisterEmbedderReference( +- const TracedGlobal& ref) { ++ const TracedReferenceBase& ref) { + if (ref.IsEmpty()) return; + + i::Heap* const heap = reinterpret_cast(isolate_)->heap(); +- heap->RegisterExternallyReferencedObject(reinterpret_cast(*ref)); ++ heap->RegisterExternallyReferencedObject( ++ reinterpret_cast(ref.val_)); + } + + void EmbedderHeapTracer::IterateTracedGlobalHandles( +@@ -10360,6 +10361,26 @@ void EmbedderHeapTracer::IterateTracedGl + isolate->global_handles()->IterateTracedNodes(visitor); + } + ++bool EmbedderHeapTracer::IsRootForNonTracingGC( ++ const v8::TracedReference& handle) { ++ return true; ++} ++ ++bool EmbedderHeapTracer::IsRootForNonTracingGC( ++ const v8::TracedGlobal& handle) { ++ return true; ++} ++ ++void EmbedderHeapTracer::ResetHandleInNonTracingGC( ++ const v8::TracedReference& handle) { ++ UNREACHABLE(); ++} ++ ++void EmbedderHeapTracer::ResetHandleInNonTracingGC( ++ const v8::TracedGlobal& handle) { ++ UNREACHABLE(); ++} ++ + namespace internal { + + const size_t HandleScopeImplementer::kEnteredContextsOffset = +diff -up chromium-78.0.3904.70/v8/src/handles/global-handles.cc.implement-tracedreference chromium-78.0.3904.70/v8/src/handles/global-handles.cc +--- chromium-78.0.3904.70/v8/src/handles/global-handles.cc.implement-tracedreference 2019-10-24 09:20:39.954123225 -0400 ++++ chromium-78.0.3904.70/v8/src/handles/global-handles.cc 2019-10-24 09:21:45.911857072 -0400 +@@ -901,8 +901,13 @@ void GlobalHandles::IdentifyWeakUnmodifi + DCHECK(node->is_root()); + if (is_unmodified(node->location())) { + v8::Value* value = ToApi(node->handle()); +- node->set_root(tracer->IsRootForNonTracingGC( +- *reinterpret_cast*>(&value))); ++ if (node->has_destructor()) { ++ node->set_root(tracer->IsRootForNonTracingGC( ++ *reinterpret_cast*>(&value))); ++ } else { ++ node->set_root(tracer->IsRootForNonTracingGC( ++ *reinterpret_cast*>(&value))); ++ } + } + } + } +@@ -990,7 +995,7 @@ void GlobalHandles::IterateYoungWeakUnmo + } else { + v8::Value* value = ToApi(node->handle()); + tracer->ResetHandleInNonTracingGC( +- *reinterpret_cast*>(&value)); ++ *reinterpret_cast*>(&value)); + DCHECK(!node->IsInUse()); + } + +@@ -1271,8 +1276,13 @@ void GlobalHandles::IterateTracedNodes( + for (TracedNode* node : *traced_nodes_) { + if (node->IsInUse()) { + v8::Value* value = ToApi(node->handle()); +- visitor->VisitTracedGlobalHandle( +- *reinterpret_cast*>(&value)); ++ if (node->has_destructor()) { ++ visitor->VisitTracedGlobalHandle( ++ *reinterpret_cast*>(&value)); ++ } else { ++ visitor->VisitTracedReference( ++ *reinterpret_cast*>(&value)); ++ } + } + } + } +diff -up chromium-78.0.3904.70/v8/src/heap/embedder-tracing.h.implement-tracedreference chromium-78.0.3904.70/v8/src/heap/embedder-tracing.h +--- chromium-78.0.3904.70/v8/src/heap/embedder-tracing.h.implement-tracedreference 2019-10-24 09:22:03.664519559 -0400 ++++ chromium-78.0.3904.70/v8/src/heap/embedder-tracing.h 2019-10-24 09:22:45.197729964 -0400 +@@ -57,7 +57,12 @@ class V8_EXPORT_PRIVATE LocalEmbedderHea + bool IsRootForNonTracingGC(const v8::TracedGlobal& handle) { + return !InUse() || remote_tracer_->IsRootForNonTracingGC(handle); + } +- void ResetHandleInNonTracingGC(const v8::TracedGlobal& handle) { ++ ++ bool IsRootForNonTracingGC(const v8::TracedReference& handle) { ++ return !InUse() || remote_tracer_->IsRootForNonTracingGC(handle); ++ } ++ ++ void ResetHandleInNonTracingGC(const v8::TracedReference& handle) { + // Resetting is only called when IsRootForNonTracingGC returns false which + // can only happen the EmbedderHeapTracer is set on API level. + DCHECK(InUse());