diff --git a/chromium-77-clang.patch b/chromium-77-clang.patch new file mode 100644 index 0000000..a57b5a4 --- /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-78-revert-noexcept-r1.patch b/chromium-78-revert-noexcept-r1.patch new file mode 100644 index 0000000..408d618 --- /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 0000000..4856c36 --- /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-v8-tracedreference-fix.patch b/chromium-78.0.3904.70-v8-tracedreference-fix.patch new file mode 100644 index 0000000..789bdd0 --- /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.spec b/chromium.spec index 764e85d..c03e832 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* @@ -209,7 +209,8 @@ Patch53: chromium-78.0.3904.70-unbundle-zlib.patch # Needs to be submitted.. Patch54: chromium-77.0.3865.75-gcc-include-memory.patch # https://chromium.googlesource.com/chromium/src/+/6b633c4b14850df376d5cec571699018772f358e -Patch55: chromium-77.0.3865.75-base-gcc-no-alignas.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 @@ -230,6 +231,14 @@ Patch63: chromium-78-pm-crash.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 @@ -759,6 +768,10 @@ udev. %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} @@ -992,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' \ @@ -1076,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' \ diff --git a/v8-implement-tracedreference.patch b/v8-implement-tracedreference.patch new file mode 100644 index 0000000..7dc7487 --- /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());