commit 333adfcd3829e396207f60316598909ba36b7f8e Author: Tomas Popela <tpopela(a)redhat.com&gt; Date: Wed Aug 14 14:38:51 2019 +0200 Backport more build fixes from upstream ...-76.0.3809.100-gcc-ambigous-instantiation.patch | 39 ++++ ...m-76.0.3809.100-gcc-feature-policy-parser.patch | 76 +++++++ ...m-76.0.3809.100-gcc-hasfraction-constexpr.patch | 32 +++ ...3809.100-gcc-move-explicit-initialization.patch | 97 +++++++++ chromium-76.0.3809.100-quiche-compile-fix.patch | 225 +++++++++++++++++++++ chromium-76.0.3809.100-throttling-dead-beef.patch | 30 +++ chromium-76.0.3809.100-weak-ptr-no-except.patch | 66 ++++++ chromium.spec | 21 ++ 8 files changed, 586 insertions(+) --- diff --git a/chromium-76.0.3809.100-gcc-ambigous-instantiation.patch b/chromium-76.0.3809.100-gcc-ambigous-instantiation.patch new file mode 100644 index 0000000..587abf3 --- /dev/null +++ b/chromium-76.0.3809.100-gcc-ambigous-instantiation.patch @@ -0,0 +1,39 @@ +From 52b5ceac95b67491b1c71f0ef9a32b778bbbaa2e Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Wed, 05 Jun 2019 19:46:55 +0000 +Subject: [PATCH] GCC: avoid ambiguous NoDestructor creation in GetNeverSniffedMimeTypes. + +Use brace-list notation to wrap the already existing brace-list for +initializing the flat-set. This resolves an ambiguous instantiation +in GCC. + +Bug: 819294 +Change-Id: I89ddf12522d62a5140a8c2c41dc98e30ec7a0e78 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1645774 +Reviewed-by: Matt Menke <mmenke(a)chromium.org&gt; +Commit-Queue: José Dapena Paz <jose.dapena(a)lge.com&gt; +Cr-Commit-Position: refs/heads/master@{#666401} +--- + +diff --git a/services/network/cross_origin_read_blocking.cc b/services/network/cross_origin_read_blocking.cc +index 30999c0..60a03f6 100644 +--- a/services/network/cross_origin_read_blocking.cc ++++ b/services/network/cross_origin_read_blocking.cc +@@ -211,7 +211,7 @@ + // confirmation sniffing because images, scripts, etc. are frequently + // mislabelled by http servers as HTML/JSON/XML). + base::flat_set<std::string>& GetNeverSniffedMimeTypes() { +- static base::NoDestructor<base::flat_set<std::string>> s_types({ ++ static base::NoDestructor<base::flat_set<std::string>> s_types{{ + // The list below has been populated based on most commonly used content + // types according to HTTP Archive - see: + // https://github.com/whatwg/fetch/issues/860#issuecomment-457330454 +@@ -224,7 +224,7 @@ + "application/x-www-form-urlencoded", + "application/zip", + "text/event-stream", +- }); ++ }}; + + // All items need to be lower-case, to support case-insensitive comparisons + // later. diff --git a/chromium-76.0.3809.100-gcc-feature-policy-parser.patch b/chromium-76.0.3809.100-gcc-feature-policy-parser.patch new file mode 100644 index 0000000..0dbffd5 --- /dev/null +++ b/chromium-76.0.3809.100-gcc-feature-policy-parser.patch @@ -0,0 +1,76 @@ +From 0aca7b8dea0f52ba7bd58dfce4ac236ee60670a8 Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Tue, 04 Jun 2019 19:44:58 +0200 +Subject: [PATCH] GCC: FeaturePolicyParser ParseValueForFuzzer is not in anonymous namespace + +Compilation fails because we are declaring ParseValueForFuzzer as friend method, +but we are declaring it is in anonymous namespace. Moving to global namespace +still fails (in this case in Clang). + +So final solution is making it a public static method of FeaturePolicyParser. + +Bug: 819294 +Change-Id: Iea307cb6faef675b748d6eb5da2175dcbb17fdc7 +--- + +diff --git a/third_party/blink/renderer/core/feature_policy/feature_policy_parser.cc b/third_party/blink/renderer/core/feature_policy/feature_policy_parser.cc +index 3b7f4a9..eaee409 100644 +--- a/third_party/blink/renderer/core/feature_policy/feature_policy_parser.cc ++++ b/third_party/blink/renderer/core/feature_policy/feature_policy_parser.cc +@@ -317,6 +317,13 @@ + return value; + } + ++void FeaturePolicyParser::ParseValueForFuzzer( ++ blink::mojom::PolicyValueType feature_type, ++ const WTF::String& value_string) { ++ bool ok; ++ ParseValueForType(feature_type, value_string, &ok); ++} ++ + bool IsFeatureDeclared(mojom::FeaturePolicyFeature feature, + const ParsedFeaturePolicy& policy) { + return std::any_of(policy.begin(), policy.end(), +diff --git a/third_party/blink/renderer/core/feature_policy/feature_policy_parser.h b/third_party/blink/renderer/core/feature_policy/feature_policy_parser.h +index fd25d90..36af405 100644 +--- a/third_party/blink/renderer/core/feature_policy/feature_policy_parser.h ++++ b/third_party/blink/renderer/core/feature_policy/feature_policy_parser.h +@@ -16,9 +16,6 @@ + #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" + #include "third_party/blink/renderer/platform/wtf/vector.h" + +-// Forward declare for friendship. +-void ParseValueForFuzzer(blink::mojom::PolicyValueType, const WTF::String&); +- + namespace blink { + + class Document; +@@ -79,8 +76,9 @@ + const FeatureNameMap& feature_names, + ExecutionContext* execution_context = nullptr); + ++ static void ParseValueForFuzzer(mojom::PolicyValueType, const String&); ++ + private: +- friend void ::ParseValueForFuzzer(mojom::PolicyValueType, const String&); + static PolicyValue GetFallbackValueForFeature( + mojom::FeaturePolicyFeature feature); + static PolicyValue ParseValueForType(mojom::PolicyValueType feature_type, +diff --git a/third_party/blink/renderer/core/feature_policy/feature_policy_value_fuzzer.cc b/third_party/blink/renderer/core/feature_policy/feature_policy_value_fuzzer.cc +index 7f8e6aa..53350e43 100644 +--- a/third_party/blink/renderer/core/feature_policy/feature_policy_value_fuzzer.cc ++++ b/third_party/blink/renderer/core/feature_policy/feature_policy_value_fuzzer.cc +@@ -23,9 +23,9 @@ + extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + static blink::BlinkFuzzerTestSupport test_support = + blink::BlinkFuzzerTestSupport(); +- ParseValueForFuzzer(blink::mojom::PolicyValueType::kBool, +- WTF::String(data, size)); +- ParseValueForFuzzer(blink::mojom::PolicyValueType::kDecDouble, +- WTF::String(data, size)); ++ blink::FeaturePolicyParser::ParseValueForFuzzer( ++ blink::mojom::PolicyValueType::kBool, WTF::String(data, size)); ++ blink::FeaturePolicyParser::ParseValueForFuzzer( ++ blink::mojom::PolicyValueType::kDecDouble, WTF::String(data, size)); + return 0; + } diff --git a/chromium-76.0.3809.100-gcc-hasfraction-constexpr.patch b/chromium-76.0.3809.100-gcc-hasfraction-constexpr.patch new file mode 100644 index 0000000..26bba05 --- /dev/null +++ b/chromium-76.0.3809.100-gcc-hasfraction-constexpr.patch @@ -0,0 +1,32 @@ +From cf6d6b40d711fce93a24a2cf517fa3becdbae8bb Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Wed, 05 Jun 2019 17:18:40 +0000 +Subject: [PATCH] Make blink::LayoutUnit::HasFraction constexpr + +Other HasFraction methods as in PhysicalUnit are declared already +constexpr and using it. It breaks GCC build. + +Bug: 819294. +Change-Id: I0c4bd9bd206d45cf31f7fa815ce8533718a425cb +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1645222 +Reviewed-by: vmpstr <vmpstr(a)chromium.org&gt; +Reviewed-by: Xianzhu Wang <wangxianzhu(a)chromium.org&gt; +Commit-Queue: José Dapena Paz <jose.dapena(a)lge.com&gt; +Cr-Commit-Position: refs/heads/master@{#666336} +--- + +diff --git a/third_party/blink/renderer/platform/geometry/layout_unit.h b/third_party/blink/renderer/platform/geometry/layout_unit.h +index f073986..b6dbc76 100644 +--- a/third_party/blink/renderer/platform/geometry/layout_unit.h ++++ b/third_party/blink/renderer/platform/geometry/layout_unit.h +@@ -202,7 +202,9 @@ + return value_ > 0 ? LayoutUnit() : *this; + } + +- bool HasFraction() const { return RawValue() % kFixedPointDenominator; } ++ constexpr bool HasFraction() const { ++ return RawValue() % kFixedPointDenominator; ++ } + + LayoutUnit Fraction() const { + // Compute fraction using the mod operator to preserve the sign of the value diff --git a/chromium-76.0.3809.100-gcc-move-explicit-initialization.patch b/chromium-76.0.3809.100-gcc-move-explicit-initialization.patch new file mode 100644 index 0000000..1d4b90f --- /dev/null +++ b/chromium-76.0.3809.100-gcc-move-explicit-initialization.patch @@ -0,0 +1,97 @@ +From dcb55fb8f18abe5f43d260aa67b14b2dc996f992 Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Tue, 11 Jun 2019 08:00:13 +0000 +Subject: [PATCH] GCC: move explicit specialization out of RunInfo + +Explicit specialization in non-namespace scope is not allowed in C++, and GCC breaks +build because of that. Move the template specializations out of RunInfo declaration +in shape_result_inline_headeres.h to fix the GCC build issue. + +Bug: 819294 +Change-Id: Id083852bcf8e9efbdc911fdad28fd8767d2905d0 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1651728 +Reviewed-by: Kinuko Yasuda <kinuko(a)chromium.org&gt; +Commit-Queue: José Dapena Paz <jose.dapena(a)lge.com&gt; +Cr-Commit-Position: refs/heads/master@{#667901} +--- + +diff --git a/third_party/blink/renderer/platform/fonts/shaping/shape_result_inline_headers.h b/third_party/blink/renderer/platform/fonts/shaping/shape_result_inline_headers.h +index 76ee6091..c14d3a0 100644 +--- a/third_party/blink/renderer/platform/fonts/shaping/shape_result_inline_headers.h ++++ b/third_party/blink/renderer/platform/fonts/shaping/shape_result_inline_headers.h +@@ -251,37 +251,6 @@ + template <bool has_non_zero_glyph_offsets> + struct iterator final {}; + +- // For non-zero glyph offset array +- template <> +- struct iterator<true> final { +- // The constructor for ShapeResult +- explicit iterator(const GlyphOffsetArray& array) +- : pointer(array.storage_.get()) { +- DCHECK(pointer); +- } +- +- // The constructor for ShapeResultView +- explicit iterator(const GlyphDataRange& range) : pointer(range.offsets) { +- DCHECK(pointer); +- } +- +- GlyphOffset operator*() const { return *pointer; } +- void operator++() { ++pointer; } +- +- const GlyphOffset* pointer; +- }; +- +- // For zero glyph offset array +- template <> +- struct iterator<false> final { +- explicit iterator(const GlyphOffsetArray& array) { +- DCHECK(!array.HasStorage()); +- } +- explicit iterator(const GlyphDataRange& range) { DCHECK(!range.offsets); } +- GlyphOffset operator*() const { return GlyphOffset(); } +- void operator++() {} +- }; +- + template <bool has_non_zero_glyph_offsets> + iterator<has_non_zero_glyph_offsets> GetIterator() const { + return iterator<has_non_zero_glyph_offsets>(*this); +@@ -495,6 +464,37 @@ + float width_; + }; + ++// For non-zero glyph offset array ++template <> ++struct ShapeResult::RunInfo::GlyphOffsetArray::iterator<true> final { ++ // The constructor for ShapeResult ++ explicit iterator(const GlyphOffsetArray& array) ++ : pointer(array.storage_.get()) { ++ DCHECK(pointer); ++ } ++ ++ // The constructor for ShapeResultView ++ explicit iterator(const GlyphDataRange& range) : pointer(range.offsets) { ++ DCHECK(pointer); ++ } ++ ++ GlyphOffset operator*() const { return *pointer; } ++ void operator++() { ++pointer; } ++ ++ const GlyphOffset* pointer; ++}; ++ ++// For zero glyph offset array ++template <> ++struct ShapeResult::RunInfo::GlyphOffsetArray::iterator<false> final { ++ explicit iterator(const GlyphOffsetArray& array) { ++ DCHECK(!array.HasStorage()); ++ } ++ explicit iterator(const GlyphDataRange& range) { DCHECK(!range.offsets); } ++ GlyphOffset operator*() const { return GlyphOffset(); } ++ void operator++() {} ++}; ++ + // Find the range of HarfBuzzRunGlyphData for the specified character index + // range. This function uses binary search twice, hence O(2 log n). + inline ShapeResult::RunInfo::GlyphDataRange diff --git a/chromium-76.0.3809.100-quiche-compile-fix.patch b/chromium-76.0.3809.100-quiche-compile-fix.patch new file mode 100644 index 0000000..98789d9 --- /dev/null +++ b/chromium-76.0.3809.100-quiche-compile-fix.patch @@ -0,0 +1,225 @@ +diff -up chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/crypto/transport_parameters.cc.quiche-compile-fix chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/crypto/transport_parameters.cc +--- chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/crypto/transport_parameters.cc.quiche-compile-fix 2019-08-14 09:58:07.721193200 +0200 ++++ chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/crypto/transport_parameters.cc 2019-08-14 09:59:33.131041525 +0200 +@@ -62,37 +62,37 @@ const size_t kStatelessResetTokenLength + std::string TransportParameterIdToString( + TransportParameters::TransportParameterId param_id) { + switch (param_id) { +- case kOriginalConnectionId: ++ case TransportParameters::kOriginalConnectionId: + return "original_connection_id"; +- case kIdleTimeout: ++ case TransportParameters::kIdleTimeout: + return "idle_timeout"; +- case kStatelessResetToken: ++ case TransportParameters::kStatelessResetToken: + return "stateless_reset_token"; +- case kMaxPacketSize: ++ case TransportParameters::kMaxPacketSize: + return "max_packet_size"; +- case kInitialMaxData: ++ case TransportParameters::kInitialMaxData: + return "initial_max_data"; +- case kInitialMaxStreamDataBidiLocal: ++ case TransportParameters::kInitialMaxStreamDataBidiLocal: + return "initial_max_stream_data_bidi_local"; +- case kInitialMaxStreamDataBidiRemote: ++ case TransportParameters::kInitialMaxStreamDataBidiRemote: + return "initial_max_stream_data_bidi_remote"; +- case kInitialMaxStreamDataUni: ++ case TransportParameters::kInitialMaxStreamDataUni: + return "initial_max_stream_data_uni"; +- case kInitialMaxStreamsBidi: ++ case TransportParameters::kInitialMaxStreamsBidi: + return "initial_max_streams_bidi"; +- case kInitialMaxStreamsUni: ++ case TransportParameters::kInitialMaxStreamsUni: + return "initial_max_streams_uni"; +- case kAckDelayExponent: ++ case TransportParameters::kAckDelayExponent: + return "ack_delay_exponent"; +- case kMaxAckDelay: ++ case TransportParameters::kMaxAckDelay: + return "max_ack_delay"; +- case kDisableMigration: ++ case TransportParameters::kDisableMigration: + return "disable_migration"; +- case kPreferredAddress: ++ case TransportParameters::kPreferredAddress: + return "preferred_address"; +- case kGoogleQuicParam: ++ case TransportParameters::kGoogleQuicParam: + return "google"; +- case kGoogleQuicVersion: ++ case TransportParameters::kGoogleQuicVersion: + return "google-version"; + } + return "Unknown(" + QuicTextUtils::Uint64ToString(param_id) + ")"; +@@ -390,7 +390,7 @@ bool SerializeTransportParameters(const + CBB original_connection_id_param; + if (!in.original_connection_id.IsEmpty()) { + DCHECK_EQ(Perspective::IS_SERVER, in.perspective); +- if (!CBB_add_u16(&params, kOriginalConnectionId) || ++ if (!CBB_add_u16(&params, TransportParameters::kOriginalConnectionId) || + !CBB_add_u16_length_prefixed(&params, &original_connection_id_param) || + !CBB_add_bytes( + &original_connection_id_param, +@@ -412,7 +412,7 @@ bool SerializeTransportParameters(const + if (!in.stateless_reset_token.empty()) { + DCHECK_EQ(kStatelessResetTokenLength, in.stateless_reset_token.size()); + DCHECK_EQ(Perspective::IS_SERVER, in.perspective); +- if (!CBB_add_u16(&params, kStatelessResetToken) || ++ if (!CBB_add_u16(&params, TransportParameters::kStatelessResetToken) || + !CBB_add_u16_length_prefixed(&params, &stateless_reset_token_param) || + !CBB_add_bytes(&stateless_reset_token_param, + in.stateless_reset_token.data(), +@@ -438,7 +438,7 @@ bool SerializeTransportParameters(const + + // disable_migration + if (in.disable_migration) { +- if (!CBB_add_u16(&params, kDisableMigration) || ++ if (!CBB_add_u16(&params, TransportParameters::kDisableMigration) || + !CBB_add_u16(&params, 0u)) { // 0 is the length of this parameter. + QUIC_BUG << "Failed to write disable_migration for " << in; + return false; +@@ -458,7 +458,7 @@ bool SerializeTransportParameters(const + QUIC_BUG << "Bad lengths " << *in.preferred_address; + return false; + } +- if (!CBB_add_u16(&params, kPreferredAddress) || ++ if (!CBB_add_u16(&params, TransportParameters::kPreferredAddress) || + !CBB_add_u16_length_prefixed(&params, &preferred_address_params) || + !CBB_add_bytes( + &preferred_address_params, +@@ -491,7 +491,7 @@ bool SerializeTransportParameters(const + if (in.google_quic_params) { + const QuicData& serialized_google_quic_params = + in.google_quic_params->GetSerialized(); +- if (!CBB_add_u16(&params, kGoogleQuicParam) || ++ if (!CBB_add_u16(&params, TransportParameters::kGoogleQuicParam) || + !CBB_add_u16_length_prefixed(&params, &google_quic_params) || + !CBB_add_bytes(&google_quic_params, + reinterpret_cast<const uint8_t*>( +@@ -505,7 +505,7 @@ bool SerializeTransportParameters(const + + // Google-specific version extension. + CBB google_version_params; +- if (!CBB_add_u16(&params, kGoogleQuicVersion) || ++ if (!CBB_add_u16(&params, TransportParameters::kGoogleQuicVersion) || + !CBB_add_u16_length_prefixed(&params, &google_version_params) || + !CBB_add_u32(&google_version_params, in.version)) { + QUIC_BUG << "Failed to write Google version extension for " << in; +@@ -565,7 +565,7 @@ bool ParseTransportParameters(const uint + } + bool parse_success = true; + switch (param_id) { +- case kOriginalConnectionId: ++ case TransportParameters::kOriginalConnectionId: + if (!out->original_connection_id.IsEmpty()) { + QUIC_DLOG(ERROR) << "Received a second original connection ID"; + return false; +@@ -581,10 +581,10 @@ bool ParseTransportParameters(const uint + CBS_len(&value)); + } + break; +- case kIdleTimeout: ++ case TransportParameters::kIdleTimeout: + parse_success = out->idle_timeout_milliseconds.ReadFromCbs(&value); + break; +- case kStatelessResetToken: ++ case TransportParameters::kStatelessResetToken: + if (!out->stateless_reset_token.empty()) { + QUIC_DLOG(ERROR) << "Received a second stateless reset token"; + return false; +@@ -597,36 +597,36 @@ bool ParseTransportParameters(const uint + out->stateless_reset_token.assign(CBS_data(&value), + CBS_data(&value) + CBS_len(&value)); + break; +- case kMaxPacketSize: ++ case TransportParameters::kMaxPacketSize: + parse_success = out->max_packet_size.ReadFromCbs(&value); + break; +- case kInitialMaxData: ++ case TransportParameters::kInitialMaxData: + parse_success = out->initial_max_data.ReadFromCbs(&value); + break; +- case kInitialMaxStreamDataBidiLocal: ++ case TransportParameters::kInitialMaxStreamDataBidiLocal: + parse_success = + out->initial_max_stream_data_bidi_local.ReadFromCbs(&value); + break; +- case kInitialMaxStreamDataBidiRemote: ++ case TransportParameters::kInitialMaxStreamDataBidiRemote: + parse_success = + out->initial_max_stream_data_bidi_remote.ReadFromCbs(&value); + break; +- case kInitialMaxStreamDataUni: ++ case TransportParameters::kInitialMaxStreamDataUni: + parse_success = out->initial_max_stream_data_uni.ReadFromCbs(&value); + break; +- case kInitialMaxStreamsBidi: ++ case TransportParameters::kInitialMaxStreamsBidi: + parse_success = out->initial_max_streams_bidi.ReadFromCbs(&value); + break; +- case kInitialMaxStreamsUni: ++ case TransportParameters::kInitialMaxStreamsUni: + parse_success = out->initial_max_streams_uni.ReadFromCbs(&value); + break; +- case kAckDelayExponent: ++ case TransportParameters::kAckDelayExponent: + parse_success = out->ack_delay_exponent.ReadFromCbs(&value); + break; +- case kMaxAckDelay: ++ case TransportParameters::kMaxAckDelay: + parse_success = out->max_ack_delay.ReadFromCbs(&value); + break; +- case kDisableMigration: ++ case TransportParameters::kDisableMigration: + if (out->disable_migration) { + QUIC_DLOG(ERROR) << "Received a second disable migration"; + return false; +@@ -638,7 +638,7 @@ bool ParseTransportParameters(const uint + } + out->disable_migration = true; + break; +- case kPreferredAddress: { ++ case TransportParameters::kPreferredAddress: { + uint16_t ipv4_port, ipv6_port; + in_addr ipv4_address; + in6_addr ipv6_address; +@@ -692,7 +692,7 @@ bool ParseTransportParameters(const uint + QuicMakeUnique<TransportParameters::PreferredAddress>( + preferred_address); + } break; +- case kGoogleQuicParam: { ++ case TransportParameters::kGoogleQuicParam: { + if (out->google_quic_params) { + QUIC_DLOG(ERROR) << "Received a second Google parameter"; + return false; +@@ -701,7 +701,7 @@ bool ParseTransportParameters(const uint + reinterpret_cast<const char*>(CBS_data(&value)), CBS_len(&value)); + out->google_quic_params = CryptoFramer::ParseMessage(serialized_params); + } break; +- case kGoogleQuicVersion: { ++ case TransportParameters::kGoogleQuicVersion: { + if (!CBS_get_u32(&value, &out->version)) { + QUIC_DLOG(ERROR) << "Failed to parse Google version extension"; + return false; +diff -up chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/quic_socket_address_coder.cc.quiche-compile-fix chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/quic_socket_address_coder.cc +--- chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/quic_socket_address_coder.cc.quiche-compile-fix 2019-08-14 09:59:19.139902052 +0200 ++++ chromium-76.0.3809.100/net/third_party/quiche/src/quic/core/quic_socket_address_coder.cc 2019-08-14 09:59:33.132041535 +0200 +@@ -2,10 +2,12 @@ + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + +-#include <string> +- + #include "net/third_party/quiche/src/quic/core/quic_socket_address_coder.h" + ++#include <cstring> ++#include <string> ++#include <vector> ++ + namespace quic { + + namespace { diff --git a/chromium-76.0.3809.100-throttling-dead-beef.patch b/chromium-76.0.3809.100-throttling-dead-beef.patch new file mode 100644 index 0000000..5e392e6 --- /dev/null +++ b/chromium-76.0.3809.100-throttling-dead-beef.patch @@ -0,0 +1,30 @@ +From 53bb5a463ee956c70230eaa5450022185d0ddc3c Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Thu, 06 Jun 2019 07:54:05 +0000 +Subject: [PATCH] ThrottlingController::Liveness needs to be uint32_t + +We are setting kAlive and kDead values assigning values that +are bigger than the maximum signed int32. It is better to use +uint32_t in this case. + +Bug: 819294 +Change-Id: If72b48291a66a3a9db24b4c8e2d11d31936a66ee +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1645772 +Reviewed-by: Kinuko Yasuda <kinuko(a)chromium.org&gt; +Commit-Queue: José Dapena Paz <jose.dapena(a)lge.com&gt; +Cr-Commit-Position: refs/heads/master@{#666619} +--- + +diff --git a/services/network/throttling/throttling_controller.h b/services/network/throttling/throttling_controller.h +index 43751c4..3c6f87b 100644 +--- a/services/network/throttling/throttling_controller.h ++++ b/services/network/throttling/throttling_controller.h +@@ -38,7 +38,7 @@ + + // TODO(https://crbug.com/960874): Debugging code to try and shed some light + // on why the owned maps are invalid. +- enum class Liveness : int32_t { ++ enum class Liveness : uint32_t { + kAlive = 0xCA11AB13, + kDead = 0xDEADBEEF, + }; diff --git a/chromium-76.0.3809.100-weak-ptr-no-except.patch b/chromium-76.0.3809.100-weak-ptr-no-except.patch new file mode 100644 index 0000000..a392971 --- /dev/null +++ b/chromium-76.0.3809.100-weak-ptr-no-except.patch @@ -0,0 +1,66 @@ +From 0370838723e786b51e7ec8ab55014811ec3e3aa3 Mon Sep 17 00:00:00 2001 +From: Jose Dapena Paz <jose.dapena(a)lge.com&gt; +Date: Thu, 18 Jul 2019 14:26:11 +0200 +Subject: [PATCH] Make base::WeakPtr move constructor/operator noexcept to fix GCC build regression + +A GCC build regression has happened on DisjointRangeLockManager, as its move +operator and constructor were declared noexcept. This was failing because the +default implementation depended on base::WeakPtr, that did not provide +noexcept declaration for them. + +So make base::WeakPtr noexcept. + +Bug: 819294 +Change-Id: I936784b881c7c1afea136ceedbe9341e76464f95 +--- + +diff --git a/base/memory/weak_ptr.cc b/base/memory/weak_ptr.cc +index 64fd499..0efcc44 100644 +--- a/base/memory/weak_ptr.cc ++++ b/base/memory/weak_ptr.cc +@@ -46,7 +46,7 @@ + + WeakReference::~WeakReference() = default; + +-WeakReference::WeakReference(WeakReference&& other) = default; ++WeakReference::WeakReference(WeakReference&& other) noexcept = default; + + WeakReference::WeakReference(const WeakReference& other) = default; + +diff --git a/base/memory/weak_ptr.h b/base/memory/weak_ptr.h +index 72b5f1f..ccd22fd13 100644 +--- a/base/memory/weak_ptr.h ++++ b/base/memory/weak_ptr.h +@@ -116,9 +116,9 @@ + explicit WeakReference(const scoped_refptr<Flag>& flag); + ~WeakReference(); + +- WeakReference(WeakReference&& other); ++ WeakReference(WeakReference&& other) noexcept; + WeakReference(const WeakReference& other); +- WeakReference& operator=(WeakReference&& other) = default; ++ WeakReference& operator=(WeakReference&& other) noexcept = default; + WeakReference& operator=(const WeakReference& other) = default; + + bool IsValid() const; +@@ -153,9 +153,9 @@ + ~WeakPtrBase(); + + WeakPtrBase(const WeakPtrBase& other) = default; +- WeakPtrBase(WeakPtrBase&& other) = default; ++ WeakPtrBase(WeakPtrBase&& other) noexcept = default; + WeakPtrBase& operator=(const WeakPtrBase& other) = default; +- WeakPtrBase& operator=(WeakPtrBase&& other) = default; ++ WeakPtrBase& operator=(WeakPtrBase&& other) noexcept = default; + + void reset() { + ref_ = internal::WeakReference(); +@@ -236,7 +236,7 @@ + ptr_ = reinterpret_cast<uintptr_t>(t); + } + template <typename U> +- WeakPtr(WeakPtr<U>&& other) : WeakPtrBase(std::move(other)) { ++ WeakPtr(WeakPtr<U>&& other) noexcept : WeakPtrBase(std::move(other)) { + // Need to cast from U* to T* to do pointer adjustment in case of multiple + // inheritance. This also enforces the "U is a T" rule. + T* t = reinterpret_cast<U*>(other.ptr_); diff --git a/chromium.spec b/chromium.spec index 602b236..383bfa9 100644 --- a/chromium.spec +++ b/chromium.spec @@ -268,6 +268,20 @@ Patch47: chromium-76.0.3809.100-gcc-vulkan.patch Patch48: chromium-76.0.3809.100-gcc-cc-no-except.patch # https://chromium.googlesource.com/chromium/src.git/+/502e6e42633d2571c823... Patch49: chromium-76.0.3809.100-gcc-net-fetcher.patch +# https://quiche.googlesource.com/quiche.git/+/9424add9d73432a794b794479025... +Patch50: chromium-76.0.3809.100-quiche-compile-fix.patch +# https://chromium.googlesource.com/chromium/src/+/53bb5a463ee956c70230eaa5... +Patch51: chromium-76.0.3809.100-throttling-dead-beef.patch +# https://chromium.googlesource.com/chromium/src/+/52b5ceac95b67491b1c71f0e... +Patch52: chromium-76.0.3809.100-gcc-ambigous-instantiation.patch +# https://chromium.googlesource.com/chromium/src.git/+/715cb38eac889625de0c... +Patch53: chromium-76.0.3809.100-weak-ptr-no-except.patch +# https://chromium.googlesource.com/chromium/src.git/+/c6afbd59c997c2b64f11... +Patch54: chromium-76.0.3809.100-gcc-feature-policy-parser.patch +# https://chromium.googlesource.com/chromium/src.git/+/cf6d6b40d711fce93a24... +Patch55: chromium-76.0.3809.100-gcc-hasfraction-constexpr.patch +# https://chromium.googlesource.com/chromium/src.git/+/dcb55fb8f18abe5f43d2... +Patch56: chromium-76.0.3809.100-gcc-move-explicit-initialization.patch # Apply these changes to work around EPEL7 compiler issues Patch100: chromium-62.0.3202.62-kmaxskip-constexpr.patch @@ -828,6 +842,13 @@ udev. %patch47 -p1 -b .gcc-vulkan %patch48 -p1 -b .gcc-cc-no-except %patch49 -p1 -b .gcc-net-fetcher +%patch50 -p1 -b .quiche-compile-fix +%patch51 -p1 -b .throttling-dead-beef +%patch52 -p1 -b .gcc-ambigous-instantiation +%patch53 -p1 -b .weak-ptr-no-except +%patch54 -p1 -b .gcc-feature-policy-parser +%patch55 -p1 -b .gcc-hasfraction-constexpr +%patch56 -p1 -b .gcc-move-explicit-initialization # EPEL specific patches %if 0%{?rhel} == 7