[chromium-browser-privacy: 1/6] Update to 78.0.3904.70

commit 2b23ce581f3dffa99968a734329ae91cdf64226c Author: Akarshan Biswas <akarshanbiswas(a)fedoraproject.org&gt; Date: Mon Oct 28 11:49:41 2019 +0530 Update to 78.0.3904.70 UseNormalBAM.patch | 82 -- chromium-gcc9-dns_util-ambiguous-ctor.patch | 34 + chromium-gcc9-r681321.patch | 35 - chromium-gcc9-r681333.patch | 71 -- chromium-gcc9-r684731.patch | 138 --- chromium-gcc9-r688676.patch | 1471 +++++++++++++++++++++++++++ chromium-gcc9-r694853.patch | 51 + chromium-gcc9-r696834.patch | 89 ++ chromium-gcc9-r706467.patch | 48 + chromium-unbundle-zlib.patch | 32 +- chromium-v8-gcc9.patch | 32 + chromium-vaapi.spec | 48 +- enable-vaapi.patch | 55 +- fixvaapionintel.patch | 49 + link-against-harfbuzz-subset.patch | 55 - sources | 2 +- 16 files changed, 1838 insertions(+), 454 deletions(-) --- diff --git a/chromium-gcc9-dns_util-ambiguous-ctor.patch b/chromium-gcc9-dns_util-ambiguous-ctor.patch new file mode 100644 index 0000000..3512f36 --- /dev/null +++ b/chromium-gcc9-dns_util-ambiguous-ctor.patch @@ -0,0 +1,34 @@ +From 955fa508686054c120e5bf1808a8e4f7f1d3c0ad Mon Sep 17 00:00:00 2001 +From: Akarshan Biswas <akarshanbiswas(a)fedoraproject.org&gt; +Date: Sun, 27 Oct 2019 20:46:10 +0530 +Subject: [PATCH] Add std vector to Doh upgradable servers + +--- + net/dns/dns_util.cc | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/net/dns/dns_util.cc b/net/dns/dns_util.cc +index d83ff7c15..ce8b786fd 100644 +--- a/net/dns/dns_util.cc ++++ b/net/dns/dns_util.cc +@@ -144,7 +144,7 @@ const std::vector<const DohUpgradeEntry>& GetDohUpgradeList() { + // DohProviderId histogram suffix list in + // tools/metrics/histograms/histograms.xml. + static const base::NoDestructor<std::vector<const DohUpgradeEntry>> +- upgradable_servers({ ++ upgradable_servers(std::vector<DohUpgradeEntry>({ + DohUpgradeEntry( + "CleanBrowsingAdult", + {"185.228.168.10", "185.228.169.11", "2a0d:2a00:1::1", +@@ -215,7 +215,7 @@ const std::vector<const DohUpgradeEntry>& GetDohUpgradeList() { + {"9.9.9.9", "149.112.112.112", "2620:fe::fe", "2620:fe::9"}, + {"dns.quad9.net", "dns9.quad9.net"} /* DoT hostname */, + {"https://dns.quad9.net/dns-query", true /* use_post */}), +- }); ++ })); + return *upgradable_servers; + } + +-- +2.21.0 + diff --git a/chromium-gcc9-r688676.patch b/chromium-gcc9-r688676.patch new file mode 100644 index 0000000..408d618 --- /dev/null +++ b/chromium-gcc9-r688676.patch @@ -0,0 +1,1471 @@ +From 37a95dd93e553888c00cf9443a5ec738ce658e65 Mon Sep 17 00:00:00 2001 +From: Zinovy Nis <zynis(a)yandex-team.ru&gt; +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 <zynis(a)yandex-team.ru&gt; +> Reviewed-by: Jeremy Roman <jbroman(a)chromium.org&gt; +> Reviewed-by: Mike West <mkwst(a)chromium.org&gt; +> Cr-Commit-Position: refs/heads/master@{#688676} + +TBR=jbroman@chromium.org,foolip@chromium.org,mkwst@chromium.org,zynis(a)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<base::string16>& 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<base::string16>&); + 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<VideoTrackAdapterSettings> 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<SelectionPaintRange>()) {} +- OldSelectedNodes(OldSelectedNodes&& other) noexcept { ++ OldSelectedNodes(OldSelectedNodes&& other) { + paint_range = other.paint_range; + selected_map = std::move(other.selected_map); + } +@@ -205,8 +205,7 @@ + HeapHashSet<Member<const Node>>&& 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<blink::SerializedScriptValue> 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<blink::StaticBitmapImage> 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<MessagePortChannel> 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<CallbacksType> 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<media::VideoCaptureFormat> 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<cc::CrossThreadSharedBitmap> 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<WrappedDataPipeGetter>); + + 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 <typename T, wtf_size_t inlineCapacity, typename Allocator> +-inline Deque<T, inlineCapacity, Allocator>::Deque(Deque&& other) noexcept ++inline Deque<T, inlineCapacity, Allocator>::Deque(Deque&& other) + : start_(0), end_(0) { + Swap(other); + } + + template <typename T, wtf_size_t inlineCapacity, typename Allocator> + inline Deque<T, inlineCapacity, Allocator>& +-Deque<T, inlineCapacity, Allocator>::operator=(Deque&& other) noexcept { ++Deque<T, inlineCapacity, Allocator>::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>(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>(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<int, int>({{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<ValueType> elements); + HashSet& operator=(std::initializer_list<ValueType> 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<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>:: +- HashTable(HashTable&& other) noexcept ++ HashTable(HashTable&& other) + : table_(nullptr), + table_size_(0), + key_count_(0), +@@ -2008,7 +2008,7 @@ + typename Allocator> + HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>& + HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>:: +-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 <typename T, typename U, typename V, typename W> +-inline LinkedHashSet<T, U, V, W>::LinkedHashSet(LinkedHashSet&& other) noexcept ++inline LinkedHashSet<T, U, V, W>::LinkedHashSet(LinkedHashSet&& other) + : anchor_() { + Swap(other); + } +@@ -763,7 +763,7 @@ + + template <typename T, typename U, typename V, typename W> + inline LinkedHashSet<T, U, V, W>& LinkedHashSet<T, U, V, W>::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 <typename T, size_t inlineCapacity, typename U, typename V> +-inline ListHashSet<T, inlineCapacity, U, V>::ListHashSet( +- ListHashSet&& other) noexcept ++inline ListHashSet<T, inlineCapacity, U, V>::ListHashSet(ListHashSet&& other) + : head_(nullptr), tail_(nullptr) { + Swap(other); + } +@@ -796,7 +795,7 @@ + + template <typename T, size_t inlineCapacity, typename U, typename V> + inline ListHashSet<T, inlineCapacity, U, V>& +-ListHashSet<T, inlineCapacity, U, V>::operator=(ListHashSet&& other) noexcept { ++ListHashSet<T, inlineCapacity, U, V>::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<CopyAssignmentUndeclared>::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<T, otherCapacity, Allocator>&); + + // Moving. +- Vector(Vector&&) noexcept; +- Vector& operator=(Vector&&) noexcept; ++ Vector(Vector&&); ++ Vector& operator=(Vector&&); + + // Construct with an initializer list. You can do e.g. + // Vector<int> v({1, 2, 3}); +@@ -1459,7 +1459,7 @@ + + template <typename T, wtf_size_t inlineCapacity, typename Allocator> + Vector<T, inlineCapacity, Allocator>::Vector( +- Vector<T, inlineCapacity, Allocator>&& other) noexcept { ++ Vector<T, inlineCapacity, Allocator>&& 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 <typename T, wtf_size_t inlineCapacity, typename Allocator> + Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>:: +-operator=(Vector<T, inlineCapacity, Allocator>&& other) noexcept { ++operator=(Vector<T, inlineCapacity, Allocator>&& 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-gcc9-r694853.patch b/chromium-gcc9-r694853.patch new file mode 100644 index 0000000..9a77a30 --- /dev/null +++ b/chromium-gcc9-r694853.patch @@ -0,0 +1,51 @@ +From 9662ec844017690d5fd56bf0f05ef6a540dd29c1 Mon Sep 17 00:00:00 2001 +From: Tom Anderson <thomasanderson(a)chromium.org&gt; +Date: Mon, 9 Sep 2019 19:06:01 +0000 +Subject: [PATCH] Fix GCC build error + +Fixes this error: +[ 375s] In file included from ../../base/task/common/intrusive_heap.h:8, +[ 375s] from ../../base/task/thread_pool/task_source.h:17, +[ 375s] from ../../base/task/thread_pool/task_tracker.h:27, +[ 375s] from ./../../base/task/thread_pool/service_thread.cc:14, +[ 375s] from gen/base/base_jumbo_28.cc:5: +[ 375s] ../../base/containers/intrusive_heap.h:152:36: error: enumerator value + '-1' is outside the range of underlying type 'size_t' {aka 'long unsigned int'} +[ 375s] 152 | enum : size_t { kInvalidIndex = -1 }; +[ 375s] | + +Change-Id: I6044fb704931b2f8416f6b19a247ae297cd7b0d6 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1792763 +Commit-Queue: Thomas Anderson <thomasanderson(a)chromium.org&gt; +Commit-Queue: Lei Zhang <thestig(a)chromium.org&gt; +Reviewed-by: Lei Zhang <thestig(a)chromium.org&gt; +Auto-Submit: Thomas Anderson <thomasanderson(a)chromium.org&gt; +Cr-Commit-Position: refs/heads/master@{#694853} +--- + base/containers/intrusive_heap.h | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/base/containers/intrusive_heap.h b/base/containers/intrusive_heap.h +index 53d3909560c7..d7626bbc3986 100644 +--- a/base/containers/intrusive_heap.h ++++ b/base/containers/intrusive_heap.h +@@ -131,6 +131,7 @@ + + #include <algorithm> + #include <functional> ++#include <limits> + #include <type_traits> + #include <utility> + #include <vector> +@@ -149,7 +150,7 @@ namespace base { + // in place. + class BASE_EXPORT HeapHandle { + public: +- enum : size_t { kInvalidIndex = -1 }; ++ enum : size_t { kInvalidIndex = std::numeric_limits<size_t>::max() }; + + constexpr HeapHandle() = default; + constexpr HeapHandle(const HeapHandle& other) = default; +-- +2.21.0 + diff --git a/chromium-gcc9-r696834.patch b/chromium-gcc9-r696834.patch new file mode 100644 index 0000000..217c66e --- /dev/null +++ b/chromium-gcc9-r696834.patch @@ -0,0 +1,89 @@ +From f4c3c329588b78af63aad8b401da767242b86709 Mon Sep 17 00:00:00 2001 +From: Raphael Kubo da Costa <raphael.kubo.da.costa(a)intel.com&gt; +Date: Mon, 16 Sep 2019 17:05:42 +0000 +Subject: [PATCH] dns_util: Make DohUpgradeEntry non-const when used with + std::vector<> + +This fixes the build with libstdc++ (with most other standard libraries +other than libc++, in fact) after commit f93a48e3 ("Allow upgrade to DoH +during automatic mode"): + +../../../../../../usr/bin/../lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_vector.h:351:7: error: static_assert failed due to requirement 'is_same<typename remove_cv<const DohUpgradeEntry>::type, const DohUpgradeEntry>::value' "std::vector must have a non-const, non-volatile value_type" + static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value, + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +../../base/no_destructor.h:77:28: note: in instantiation of template class 'std::vector<const net::(anonymous namespace)::DohUpgradeEntry, std::allocator<const net::(anonymous namespace)::DohUpgradeEntry> >' requested here + alignas(T) char storage_[sizeof(T)]; + ^ +../../net/dns/dns_util.cc:147:7: note: in instantiation of template class 'base::NoDestructor<std::vector<const net::(anonymous namespace)::DohUpgradeEntry, std::allocator<const net::(anonymous namespace)::DohUpgradeEntry> > >' requested here + upgradable_servers({ + ^ +../../net/dns/dns_util.cc:230:36: error: invalid range expression of type 'const std::vector<const net::(anonymous namespace)::DohUpgradeEntry, std::allocator<const net::(anonymous namespace)::DohUpgradeEntry> >'; no viable 'begin' function available + for (const auto& upgrade_entry : upgradable_servers) { + ^ ~~~~~~~~~~~~~~~~~~ + +The C++ standard forbids containers of const elements. Callers of +GetDohUpgradeList() use it in a safe way anyway, and most of +DohUpgradeEntry's members are const. + +Bug: 957519 +Change-Id: I826a51823edb1184c0fae27105101e2894efe568 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1805636 +Auto-Submit: Raphael Kubo da Costa <raphael.kubo.da.costa(a)intel.com&gt; +Commit-Queue: Eric Orth <ericorth(a)chromium.org&gt; +Reviewed-by: Eric Orth <ericorth(a)chromium.org&gt; +Cr-Commit-Position: refs/heads/master@{#696834} +--- + net/dns/dns_util.cc | 13 +++++-------- + 1 file changed, 5 insertions(+), 8 deletions(-) + +diff --git a/net/dns/dns_util.cc b/net/dns/dns_util.cc +index d83ff7c15024..14997c48b23c 100644 +--- a/net/dns/dns_util.cc ++++ b/net/dns/dns_util.cc +@@ -139,11 +139,11 @@ struct DohUpgradeEntry { + const DnsConfig::DnsOverHttpsServerConfig dns_over_https_config; + }; + +-const std::vector<const DohUpgradeEntry>& GetDohUpgradeList() { ++const std::vector<DohUpgradeEntry>& GetDohUpgradeList() { + // The provider names in these entries should be kept in sync with the + // DohProviderId histogram suffix list in + // tools/metrics/histograms/histograms.xml. +- static const base::NoDestructor<std::vector<const DohUpgradeEntry>> ++ static const base::NoDestructor<std::vector<DohUpgradeEntry>> + upgradable_servers({ + DohUpgradeEntry( + "CleanBrowsingAdult", +@@ -222,8 +222,7 @@ const std::vector<const DohUpgradeEntry>& GetDohUpgradeList() { + std::vector<const DohUpgradeEntry*> GetDohUpgradeEntriesFromNameservers( + const std::vector<IPEndPoint>& dns_servers, + const std::vector<std::string>& excluded_providers) { +- const std::vector<const DohUpgradeEntry>& upgradable_servers = +- GetDohUpgradeList(); ++ const std::vector<DohUpgradeEntry>& upgradable_servers = GetDohUpgradeList(); + std::vector<const DohUpgradeEntry*> entries; + + for (const auto& server : dns_servers) { +@@ -417,8 +416,7 @@ std::vector<DnsConfig::DnsOverHttpsServerConfig> + GetDohUpgradeServersFromDotHostname( + const std::string& dot_server, + const std::vector<std::string>& excluded_providers) { +- const std::vector<const DohUpgradeEntry>& upgradable_servers = +- GetDohUpgradeList(); ++ const std::vector<DohUpgradeEntry>& upgradable_servers = GetDohUpgradeList(); + std::vector<DnsConfig::DnsOverHttpsServerConfig> doh_servers; + + if (dot_server.empty()) +@@ -451,8 +449,7 @@ GetDohUpgradeServersFromNameservers( + + std::string GetDohProviderIdForHistogramFromDohConfig( + const DnsConfig::DnsOverHttpsServerConfig& doh_server) { +- const std::vector<const DohUpgradeEntry>& upgradable_servers = +- GetDohUpgradeList(); ++ const std::vector<DohUpgradeEntry>& upgradable_servers = GetDohUpgradeList(); + for (const auto& upgrade_entry : upgradable_servers) { + if (doh_server.server_template == + upgrade_entry.dns_over_https_config.server_template) { +-- +2.21.0 + diff --git a/chromium-gcc9-r706467.patch b/chromium-gcc9-r706467.patch new file mode 100644 index 0000000..a71381d --- /dev/null +++ b/chromium-gcc9-r706467.patch @@ -0,0 +1,48 @@ +From e73aed9a5ef15102f29ac31b70290faf5c90f9fe Mon Sep 17 00:00:00 2001 +From: Evan Stade <estade(a)chromium.org&gt; +Date: Wed, 16 Oct 2019 16:01:32 +0000 +Subject: [PATCH] Fix shutdown crash in ProfileManager. + +OnProfileMarkedForPermanentDeletion should move from +ProfileManagerObserver to ProfileObserver, which would also +fix this bug. However, changing the order of members is the +quickest and most cherry-pick-able way to avoid the crash. + +Bug: 1005244 +Change-Id: If2db68c846dd418cd02864b57b9b543687fa1e03 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863518 +Auto-Submit: Evan Stade <estade(a)chromium.org&gt; +Reviewed-by: David Roger <droger(a)chromium.org&gt; +Commit-Queue: Evan Stade <estade(a)chromium.org&gt; +Cr-Commit-Position: refs/heads/master@{#706467} +--- + chrome/browser/profiles/profile_manager.h | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/chrome/browser/profiles/profile_manager.h b/chrome/browser/profiles/profile_manager.h +index b60df76d59c1..7d02af7f8f60 100644 +--- a/chrome/browser/profiles/profile_manager.h ++++ b/chrome/browser/profiles/profile_manager.h +@@ -410,6 +410,10 @@ class ProfileManager : public content::NotificationObserver, + const base::FilePath& profile_dir); + #endif // !defined(OS_ANDROID) + ++ // Destroy after |profile_info_cache_| since Profile destruction may trigger ++ // some observers to unregister themselves. ++ base::ObserverList<ProfileManagerObserver> observers_; ++ + // Object to cache various information about profiles. Contains information + // about every profile which has been created for this instance of Chrome, + // if it has not been explicitly deleted. It must be destroyed after +@@ -451,8 +455,6 @@ class ProfileManager : public content::NotificationObserver, + // Controls whether to initialize some services. Only disabled for testing. + bool do_final_services_init_ = true; + +- base::ObserverList<ProfileManagerObserver> observers_; +- + // TODO(chrome/browser/profiles/OWNERS): Usage of this in profile_manager.cc + // should likely be turned into DCHECK_CURRENTLY_ON(BrowserThread::UI) for + // consistency with surrounding code in the same file but that wasn't trivial +-- +2.21.0 + diff --git a/chromium-unbundle-zlib.patch b/chromium-unbundle-zlib.patch index d6c45ad..951a2ad 100644 --- a/chromium-unbundle-zlib.patch +++ b/chromium-unbundle-zlib.patch @@ -1,25 +1,13 @@ -From e1bbdec720a333937bd1b990ae0f7ee97db0d3b0 Mon Sep 17 00:00:00 2001 -From: Your Name <you(a)example.com&gt; -Date: Fri, 28 Jun 2019 15:56:23 +0000 -Subject: [PATCH] update zlib - ---- - third_party/perfetto/gn/BUILD.gn | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - diff --git a/third_party/perfetto/gn/BUILD.gn b/third_party/perfetto/gn/BUILD.gn -index c951f5f..297eee3 100644 +index 3bc618a..e0ddf6d 100644 --- a/third_party/perfetto/gn/BUILD.gn +++ b/third_party/perfetto/gn/BUILD.gn -@@ -200,7 +200,7 @@ group("zlib") { - "//buildtools:zlib", - ] - } else if (build_with_chromium) { -- public_configs = [ "//third_party/zlib:zlib_config" ] -+ public_configs = [ "//third_party/zlib:system_zlib" ] - public_deps = [ - "//third_party/zlib", - ] --- -2.21.0 - +@@ -244,7 +244,7 @@ if (enable_perfetto_trace_processor || perfetto_build_standalone || + "//buildtools:zlib", + ] + } else { +- public_configs = [ "//third_party/zlib:zlib_config" ] ++ public_configs = [ "//third_party/zlib:system_zlib" ] + public_deps = [ + "//third_party/zlib", + ] diff --git a/chromium-v8-gcc9.patch b/chromium-v8-gcc9.patch new file mode 100644 index 0000000..8ddb53f --- /dev/null +++ b/chromium-v8-gcc9.patch @@ -0,0 +1,32 @@ +From d16cda8fc3476cc534a756873cc8aa2692a57054 Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Thu, 22 Aug 2019 13:13:36 +0200 +Subject: [PATCH] GCC: declare noexcept move constructor/assign operators of V8StackTraceId + +blink::BlinkCloneableMessage declares default implementation of +move operator/assign operator that requires v8_inspector::V8StackTraceId +to declare its move constructor/assign operator too. + +Bug: chromium:819294 +Change-Id: Iaf626ee8245efcba372a17cdf2de448e691d41d6 +Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1796062 +Commit-Queue: José Dapena Paz <jose.dapena(a)lge.com&gt; +Reviewed-by: Yang Guo <yangguo(a)chromium.org&gt; +Cr-Commit-Position: refs/heads/master@{#63799} +--- + +diff --git a/v8/include/v8-inspector.h b/v8/include/v8-inspector.h +index ce5b777..ed4cdec 100644 +--- a/v8/include/v8-inspector.h ++++ b/v8/include/v8-inspector.h +@@ -231,7 +231,10 @@ struct V8_EXPORT V8StackTraceId { + std::pair<int64_t, int64_t> debugger_id; + + V8StackTraceId(); ++ V8StackTraceId(const V8StackTraceId&) = default; + V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id); ++ V8StackTraceId& operator=(const V8StackTraceId&) = default; ++ V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default; + ~V8StackTraceId() = default; + + bool IsInvalid() const; diff --git a/chromium-vaapi.spec b/chromium-vaapi.spec index a44002f..c2ce01f 100644 --- a/chromium-vaapi.spec +++ b/chromium-vaapi.spec @@ -70,7 +70,7 @@ %global ozone 0 ##############################Package Definitions###################################### Name: chromium-vaapi -Version: 77.0.3865.120 +Version: 78.0.3904.70 Release: 1%{?dist} Summary: A Chromium web browser with video decoding acceleration License: BSD and LGPLv2+ and ASL 2.0 and IJG and MIT and GPLv2+ and ISC and OpenSSL and (MPLv1.1 or GPLv2 or LGPLv2) @@ -206,8 +206,8 @@ ExclusiveArch: x86_64 Patch1: enable-vaapi.patch # Enable support for widevine Patch2: widevine.patch -#Use Normal BAM on Linux -Patch3: UseNormalBAM.patch +# Fix vaapi on Intel +Patch3: fixvaapionintel.patch #Fix certificare transperancy error introduced by the current stable version of chromium Patch5: cert-trans-google.patch # Bootstrap still uses python command @@ -221,16 +221,14 @@ Patch54: brand.patch Patch65: chromium-73.0.3683.75-pipewire-cstring-fix.patch # Fix header Patch68: Add-missing-header-to-fix-webrtc-build.patch +Patch69: chromium-unbundle-zlib.patch +Patch70: chromium-base-location.patch # GCC patches -Patch69: chromium-gcc9-r681333.patch -Patch70: chromium-gcc9-r681321.patch -Patch71: chromium-unbundle-zlib.patch -Patch72: chromium-base-location.patch -Patch73: chromium-gcc9-r684731.patch - -# This patch fixes linking when build with system harfbuzz is enabled -Patch74: link-against-harfbuzz-subset.patch - +Patch73: chromium-gcc9-r688676.patch +Patch74: chromium-gcc9-r694853.patch +Patch75: chromium-gcc9-r696834.patch +Patch76: chromium-gcc9-r706467.patch +Patch77: chromium-v8-gcc9.patch %description %{name} is an open-source web browser, powered by WebKit (Blink) @@ -243,16 +241,13 @@ Patch74: link-against-harfbuzz-subset.patch %if !%{freeworld} %patch54 -p1 -R %endif -%if !%{with system_harfbuzz} -%patch74 -p1 -R -%endif #Let's change the default shebang of python files. find -depth -type f -writable -name "*.py" -exec sed -iE '1s=^#! */usr/bin/\(python\|env python\)[23]\?=#!%{__python2}=' {} + ./build/linux/unbundle/remove_bundled_libraries.py --do-remove \ base/third_party/cityhash \ - base/third_party/dmg_fp \ + base/third_party/double_conversion \ base/third_party/dynamic_annotations \ base/third_party/icu \ base/third_party/libevent \ @@ -311,6 +306,7 @@ find -depth -type f -writable -name "*.py" -exec sed -iE '1s=^#! */usr/bin/\(pyt third_party/catapult/third_party/six \ third_party/catapult/tracing/third_party/d3 \ third_party/catapult/tracing/third_party/gl-matrix \ + third_party/catapult/tracing/third_party/jpeg-js \ third_party/catapult/tracing/third_party/jszip \ third_party/catapult/tracing/third_party/mannwhitneyu \ third_party/catapult/tracing/third_party/oboe \ @@ -324,6 +320,7 @@ find -depth -type f -writable -name "*.py" -exec sed -iE '1s=^#! */usr/bin/\(pyt third_party/crc32c \ third_party/cros_system_api \ third_party/dawn \ + third_party/depot_tools \ third_party/dav1d \ third_party/devscripts \ third_party/dom_distiller_js \ @@ -412,6 +409,7 @@ find -depth -type f -writable -name "*.py" -exec sed -iE '1s=^#! */usr/bin/\(pyt third_party/ply \ %endif third_party/polymer \ + third_party/private-join-and-compute \ third_party/protobuf \ third_party/protobuf/third_party/six \ third_party/pyjson5 \ @@ -461,6 +459,7 @@ find -depth -type f -writable -name "*.py" -exec sed -iE '1s=^#! */usr/bin/\(pyt third_party/xdg-utils \ third_party/yasm/run_yasm.py \ third_party/zlib/google \ + tools/grit/third_party/six \ %if !%{with system_minizip} third_party/zlib \ %endif @@ -529,6 +528,10 @@ export CC=gcc CXX=g++ # GN needs gold to bootstrap export LDFLAGS="$LDFLAGS -fuse-ld=gold" +export CXXFLAGS="$CXXFLAGS -fpermissive" +%if 0%{?fedora} <= 29 +export CXXFLAGS="$CXXFLAGS -fno-ipa-cp-clone" +%endif gn_args=( is_debug=false @@ -570,18 +573,16 @@ gn_args=( 'google_default_client_secret="%{default_client_secret}"' ) -#compiler settings -# 'clang_base_path = "/usr"' -# use_lld=false - # clang_use_chrome_plugins=false + gn_args+=( is_clang=false ) + #Jumbo stuff gn_args+=( %if %{jumbo} use_jumbo_build=true - jumbo_file_merge_limit=6 + jumbo_file_merge_limit=7 concurrent_links=1 %endif ) @@ -706,9 +707,12 @@ appstream-util validate-relax --nonet "%{buildroot}%{_metainfodir}/%{name}.appda %dir %{chromiumdir}/swiftshader %{chromiumdir}/swiftshader/libEGL.so %{chromiumdir}/swiftshader/libGLESv2.so -%{chromiumdir}/swiftshader/libvulkan.so +%{chromiumdir}/swiftshader/libvk_swiftshader.so #########################################changelogs################################################# %changelog +* Mon Oct 28 2019 Akarshan Biswas <akarshanbiswas(a)fedoraproject.org&gt; - 78.0.3904.70-1 +- Update to 78.0.3904.70 + * Sun Oct 13 2019 Akarshan Biswas <akarshanbiswas(a)fedoraproject.org&gt; - 77.0.3865.120-1 - Update to 77.0.3865.120 diff --git a/enable-vaapi.patch b/enable-vaapi.patch index dfc69ac..1dd612a 100644 --- a/enable-vaapi.patch +++ b/enable-vaapi.patch @@ -1,20 +1,20 @@ -From f183ba2daac36bea97ea3be10c6ab9ed561f1cda Mon Sep 17 00:00:00 2001 +From e04b52fc9b12f0725e76b889161ea45c776e6da5 Mon Sep 17 00:00:00 2001 From: Akarshan Biswas <akarshanbiswas(a)fedoraproject.org&gt; Date: Fri, 20 Sep 2019 19:55:45 +0530 -Subject: [PATCH] Enable VAAPI on Linux +Subject: [PATCH] Enable VAAPI on Linux --- chrome/browser/about_flags.cc | 8 ++++---- - chrome/browser/flag_descriptions.cc | 10 ++++++++-- + chrome/browser/flag_descriptions.cc | 9 ++++++--- chrome/browser/flag_descriptions.h | 10 ++++++++-- gpu/config/software_rendering_list.json | 3 ++- - 4 files changed, 22 insertions(+), 9 deletions(-) + 4 files changed, 20 insertions(+), 10 deletions(-) diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc -index 245672956..c48193fb4 100644 +index e608f06a2..c0776db45 100644 --- a/chrome/browser/about_flags.cc +++ b/chrome/browser/about_flags.cc -@@ -1563,7 +1563,7 @@ const FeatureEntry kFeatureEntries[] = { +@@ -1738,7 +1738,7 @@ const FeatureEntry kFeatureEntries[] = { "disable-accelerated-video-decode", flag_descriptions::kAcceleratedVideoDecodeName, flag_descriptions::kAcceleratedVideoDecodeDescription, @@ -23,7 +23,7 @@ index 245672956..c48193fb4 100644 SINGLE_DISABLE_VALUE_TYPE(switches::kDisableAcceleratedVideoDecode), }, { -@@ -2039,12 +2039,12 @@ const FeatureEntry kFeatureEntries[] = { +@@ -2216,12 +2216,12 @@ const FeatureEntry kFeatureEntries[] = { FEATURE_VALUE_TYPE(service_manager::features::kXRSandbox)}, #endif // !defined(OS_ANDROID) #endif // ENABLE_VR @@ -40,43 +40,42 @@ index 245672956..c48193fb4 100644 flag_descriptions::kSystemKeyboardLockDescription, kOsDesktop, FEATURE_VALUE_TYPE(features::kSystemKeyboardLock)}, diff --git a/chrome/browser/flag_descriptions.cc b/chrome/browser/flag_descriptions.cc -index 4321b01dd..e24136410 100644 +index d27bbb28f..1c6542bdd 100644 --- a/chrome/browser/flag_descriptions.cc +++ b/chrome/browser/flag_descriptions.cc -@@ -2927,15 +2927,21 @@ const char kMacSystemMediaPermissionsInfoUiDescription[] = +@@ -3071,16 +3071,19 @@ const char kMacSystemMediaPermissionsInfoUiDescription[] = #endif -// Chrome OS ------------------------------------------------------------------- -+// Chrome OS Linux------------------------------------------------------------------- - +- -#if defined(OS_CHROMEOS) -+#if defined(OS_CHROMEOS) || (defined(OS_LINUX) && !defined(OS_ANDROID)) ++// Chrome OS and Linux ------------------------------------------------------------------- ++#if defined(OS_CHROMEOS) || (defined(OS_LINUX) && !defined(OS_ANDROID)) const char kAcceleratedMjpegDecodeName[] = "Hardware-accelerated mjpeg decode for captured frame"; const char kAcceleratedMjpegDecodeDescription[] = "Enable hardware-accelerated mjpeg decode for captured frame where " "available."; -+ -+#endif -+ -+// Chrome OS -------------------------------------------------- ++#endif + ++// Chrome OS ----------------------------------------------------------------------------- + +#if defined(OS_CHROMEOS) - - const char kAppServiceAshName[] = "App Service Ash"; - const char kAppServiceAshDescription[] = + const char kAggregatedMlAppRankingName[] = "Rank suggested apps with ML."; + const char kAggregatedMlAppRankingDescription[] = + "Use the aggregated ML model to rank the suggested apps."; diff --git a/chrome/browser/flag_descriptions.h b/chrome/browser/flag_descriptions.h -index ebca9b5eb..31f7e5571 100644 +index 1f8899de1..06544e079 100644 --- a/chrome/browser/flag_descriptions.h +++ b/chrome/browser/flag_descriptions.h -@@ -1737,13 +1737,19 @@ extern const char kPermissionPromptPersistenceToggleDescription[]; +@@ -1822,13 +1822,19 @@ extern const char kPermissionPromptPersistenceToggleDescription[]; #endif // defined(OS_MACOSX) -// Chrome OS ------------------------------------------------------------------ -+// Chrome OS and Linux ------------------------------------------------------------------ ++// Chrome OS and Linux --------------------------------------------------------- -#if defined(OS_CHROMEOS) +#if defined(OS_CHROMEOS) || (defined(OS_LINUX) && !defined(OS_ANDROID)) @@ -84,20 +83,20 @@ index ebca9b5eb..31f7e5571 100644 extern const char kAcceleratedMjpegDecodeName[]; extern const char kAcceleratedMjpegDecodeDescription[]; -+#endif // defined(OS_CHROMEOS) || (defined(OS_LINUX) && !defined(OS_ANDROID)) ++#endif + -+// Chrome OS ------------------------------------------------------------------------ ++// Chrome OS ------------------------------------------------------------------- + +#if defined(OS_CHROMEOS) + - extern const char kAppServiceAshName[]; - extern const char kAppServiceAshDescription[]; + extern const char kAggregatedMlAppRankingName[]; + extern const char kAggregatedMlAppRankingDescription[]; diff --git a/gpu/config/software_rendering_list.json b/gpu/config/software_rendering_list.json -index 9def82b55..b1c76c84e 100644 +index ea1294e4c..bc52cbc8f 100644 --- a/gpu/config/software_rendering_list.json +++ b/gpu/config/software_rendering_list.json -@@ -370,11 +370,12 @@ +@@ -334,11 +334,12 @@ }, { "id": 48, diff --git a/fixvaapionintel.patch b/fixvaapionintel.patch new file mode 100644 index 0000000..a94886a --- /dev/null +++ b/fixvaapionintel.patch @@ -0,0 +1,49 @@ +From 9ff06536caf7ea51aad9fd2bb649c858eaf7ee84 Mon Sep 17 00:00:00 2001 +From: Akarshan Biswas <akarshanbiswas(a)fedoraproject.org&gt; +Date: Sat, 26 Oct 2019 10:06:30 +0530 +Subject: [PATCH] Move offending function to chromeos only + +--- + media/gpu/vaapi/vaapi_video_decode_accelerator.cc | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/media/gpu/vaapi/vaapi_video_decode_accelerator.cc b/media/gpu/vaapi/vaapi_video_decode_accelerator.cc +index f04b60f58..3e7865503 100644 +--- a/media/gpu/vaapi/vaapi_video_decode_accelerator.cc ++++ b/media/gpu/vaapi/vaapi_video_decode_accelerator.cc +@@ -63,6 +63,7 @@ void ReportToUMA(VAVDADecoderFailure failure) { + VAVDA_DECODER_FAILURES_MAX + 1); + } + ++#if defined(OS_ANDROID) || defined(OS_CHROMEOS) + // Returns true if the CPU is an Intel Gemini Lake or later (including Kaby + // Lake) Cpu platform id's are referenced from the following file in kernel + // source arch/x86/include/asm/intel-family.h +@@ -75,6 +76,7 @@ bool IsGeminiLakeOrLater() { + cpuid.model() >= kGeminiLakeModelId; + return is_geminilake_or_later; + } ++#endif + + } // namespace + +@@ -1091,6 +1093,8 @@ VaapiVideoDecodeAccelerator::DecideBufferAllocationMode() { + if (output_mode_ == VideoDecodeAccelerator::Config::OutputMode::IMPORT) + return BufferAllocationMode::kNormal; + ++#if defined(OS_ANDROID) || defined(OS_CHROMEOS) ++ // Move this to chromeOs only as it is causing problem in some intel linux drivers + // On Gemini Lake, Kaby Lake and later we can pass to libva the client's + // PictureBuffers to decode onto, which skips the use of the Vpp unit and its + // associated format reconciliation copy, avoiding all internal buffer +@@ -1107,6 +1111,7 @@ VaapiVideoDecodeAccelerator::DecideBufferAllocationMode() { + num_extra_pics_ = 3; + return BufferAllocationMode::kNone; + } ++#endif + + // If we're here, we have to use the Vpp unit and allocate buffers for + // |decoder_|; usually we'd have to allocate the |decoder_|s +-- +2.21.0 + diff --git a/sources b/sources index b5a9433..9e9cab3 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (chromium-77.0.3865.120.tar.xz) = 4c72c9e9cd9a5d7f89e33c52d117018418ce0f5d23a57341b26ce47c8f90fa55f52a0c976b6959026dc273d5b37aa57306253a9b533172cd133a815edc7bccb4 +SHA512 (chromium-78.0.3904.70.tar.xz) = 95d926ea92a0e744284a4c5fca619e3a067dd0fdfaa7c05b5a069d2a8d1159bf849335e21e5803bd28175c1994bd4ff15337ad0a3063445fab74eef113275545