From 3ee5bffeaa1597d65ca5ba698f49f8398a9b30df Mon Sep 17 00:00:00 2001 From: Tom Callaway Date: Wed, 21 Oct 2020 17:13:51 -0400 Subject: [PATCH] 86.0.4240.111 and more fixes --- chromium-86-use-range-based-algorithms.patch | 1500 ++++++++++++++++++ chromium-87-CursorFactory-include.patch | 36 + chromium-87-openscreen-include.patch | 25 + chromium.spec | 11 +- sources | 2 +- 5 files changed, 1571 insertions(+), 3 deletions(-) create mode 100644 chromium-86-use-range-based-algorithms.patch create mode 100644 chromium-87-CursorFactory-include.patch create mode 100644 chromium-87-openscreen-include.patch diff --git a/chromium-86-use-range-based-algorithms.patch b/chromium-86-use-range-based-algorithms.patch new file mode 100644 index 0000000..afbcb6e --- /dev/null +++ b/chromium-86-use-range-based-algorithms.patch @@ -0,0 +1,1500 @@ +diff -up chromium-86.0.4240.75/base/callback_list.h.a61fb57e chromium-86.0.4240.75/base/callback_list.h +--- chromium-86.0.4240.75/base/callback_list.h.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/callback_list.h 2020-10-21 16:38:29.003091331 -0400 +@@ -5,7 +5,6 @@ + #ifndef BASE_CALLBACK_LIST_H_ + #define BASE_CALLBACK_LIST_H_ + +-#include + #include + #include + #include +@@ -17,6 +16,7 @@ + #include "base/check.h" + #include "base/compiler_specific.h" + #include "base/memory/weak_ptr.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + + // OVERVIEW: +@@ -163,8 +163,8 @@ class CallbackListBase { + // Returns whether the list of registered callbacks is empty (from an external + // perspective -- meaning no remaining callbacks are live). + bool empty() const { +- return std::all_of(callbacks_.cbegin(), callbacks_.cend(), +- [](const auto& callback) { return callback.is_null(); }); ++ return ranges::all_of( ++ callbacks_, [](const auto& callback) { return callback.is_null(); }); + } + + // Calls all registered callbacks that are not canceled beforehand. If any +diff -up chromium-86.0.4240.75/base/command_line.cc.a61fb57e chromium-86.0.4240.75/base/command_line.cc +--- chromium-86.0.4240.75/base/command_line.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/command_line.cc 2020-10-21 16:38:29.003091331 -0400 +@@ -4,13 +4,13 @@ + + #include "base/command_line.h" + +-#include + #include + + #include "base/containers/span.h" + #include "base/files/file_path.h" + #include "base/logging.h" + #include "base/notreached.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/strcat.h" + #include "base/strings/string_split.h" +@@ -411,8 +411,7 @@ CommandLine::StringVector CommandLine::G + // Gather all arguments after the last switch (may include kSwitchTerminator). + StringVector args(argv_.begin() + begin_args_, argv_.end()); + // Erase only the first kSwitchTerminator (maybe "--" is a legitimate page?) +- auto switch_terminator = +- std::find(args.begin(), args.end(), kSwitchTerminator); ++ auto switch_terminator = ranges::find(args, kSwitchTerminator); + if (switch_terminator != args.end()) + args.erase(switch_terminator); + return args; +diff -up chromium-86.0.4240.75/base/containers/checked_range_unittest.cc.a61fb57e chromium-86.0.4240.75/base/containers/checked_range_unittest.cc +--- chromium-86.0.4240.75/base/containers/checked_range_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/checked_range_unittest.cc 2020-10-21 16:38:29.003091331 -0400 +@@ -8,6 +8,7 @@ + #include + #include + ++#include "base/ranges/algorithm.h" + #include "base/strings/string_piece.h" + #include "testing/gtest/include/gtest/gtest.h" + +@@ -151,9 +152,9 @@ TEST(CheckedContiguousRange, Mutable_Dat + std::vector vector = {3, 1, 4, 2, 5}; + CheckedContiguousRange> range(vector); + +- EXPECT_FALSE(std::is_sorted(vector.begin(), vector.end())); ++ EXPECT_FALSE(ranges::is_sorted(vector)); + std::sort(range.data(), range.data() + range.size()); +- EXPECT_TRUE(std::is_sorted(vector.begin(), vector.end())); ++ EXPECT_TRUE(ranges::is_sorted(vector)); + } + + TEST(CheckedContiguousRange, DataSizeEmpty_Constexpr) { +diff -up chromium-86.0.4240.75/base/containers/circular_deque.h.a61fb57e chromium-86.0.4240.75/base/containers/circular_deque.h +--- chromium-86.0.4240.75/base/containers/circular_deque.h.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/circular_deque.h 2020-10-21 16:38:29.003091331 -0400 +@@ -14,6 +14,7 @@ + #include "base/check_op.h" + #include "base/containers/vector_buffer.h" + #include "base/macros.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/template_util.h" + +@@ -1097,7 +1098,7 @@ class circular_deque { + // Implementations of base::Erase[If] (see base/stl_util.h). + template + size_t Erase(circular_deque& container, const Value& value) { +- auto it = std::remove(container.begin(), container.end(), value); ++ auto it = ranges::remove(container, value); + size_t removed = std::distance(it, container.end()); + container.erase(it, container.end()); + return removed; +@@ -1105,7 +1106,7 @@ size_t Erase(circular_deque& containe + + template + size_t EraseIf(circular_deque& container, Predicate pred) { +- auto it = std::remove_if(container.begin(), container.end(), pred); ++ auto it = ranges::remove_if(container, pred); + size_t removed = std::distance(it, container.end()); + container.erase(it, container.end()); + return removed; +diff -up chromium-86.0.4240.75/base/containers/flat_map_unittest.cc.a61fb57e chromium-86.0.4240.75/base/containers/flat_map_unittest.cc +--- chromium-86.0.4240.75/base/containers/flat_map_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/flat_map_unittest.cc 2020-10-21 16:38:29.003091331 -0400 +@@ -8,6 +8,7 @@ + #include + + #include "base/macros.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_piece.h" + #include "base/test/move_only_int.h" + #include "testing/gmock/include/gmock/gmock.h" +@@ -214,7 +215,7 @@ TEST(FlatMap, InsertOrAssignMoveOnlyKey) + base::flat_map map; + for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) { + map.insert_or_assign(MoveOnlyInt(i), i); +- EXPECT_TRUE(std::is_sorted(map.begin(), map.end())); ++ EXPECT_TRUE(ranges::is_sorted(map)); + } + } + +@@ -249,7 +250,7 @@ TEST(FlatMap, InsertOrAssignMoveOnlyKeyW + base::flat_map map; + for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) { + map.insert_or_assign(map.end(), MoveOnlyInt(i), i); +- EXPECT_TRUE(std::is_sorted(map.begin(), map.end())); ++ EXPECT_TRUE(ranges::is_sorted(map)); + } + } + +@@ -294,7 +295,7 @@ TEST(FlatMap, TryEmplaceMoveOnlyKey) { + base::flat_map map; + for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) { + map.try_emplace(MoveOnlyInt(i), i); +- EXPECT_TRUE(std::is_sorted(map.begin(), map.end())); ++ EXPECT_TRUE(ranges::is_sorted(map)); + } + } + +@@ -340,7 +341,7 @@ TEST(FlatMap, TryEmplaceMoveOnlyKeyWithH + base::flat_map map; + for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) { + map.try_emplace(map.end(), MoveOnlyInt(i), i); +- EXPECT_TRUE(std::is_sorted(map.begin(), map.end())); ++ EXPECT_TRUE(ranges::is_sorted(map)); + } + } + +diff -up chromium-86.0.4240.75/base/containers/flat_tree.h.a61fb57e chromium-86.0.4240.75/base/containers/flat_tree.h +--- chromium-86.0.4240.75/base/containers/flat_tree.h.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/flat_tree.h 2020-10-21 16:38:29.004091339 -0400 +@@ -11,6 +11,7 @@ + #include + #include + ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/template_util.h" + +@@ -753,11 +754,10 @@ template ::replace( + underlying_type&& body) { + // Ensure that |body| is sorted and has no repeated elements. +- DCHECK(std::is_sorted(body.begin(), body.end(), value_comp())); +- DCHECK(std::adjacent_find(body.begin(), body.end(), +- [this](const auto& lhs, const auto& rhs) { +- return !value_comp()(lhs, rhs); +- }) == body.end()); ++ DCHECK(ranges::is_sorted(body, value_comp())); ++ DCHECK(ranges::adjacent_find(body, [this](const auto& lhs, const auto& rhs) { ++ return !value_comp()(lhs, rhs); ++ }) == body.end()); + impl_.body_ = std::move(body); + } + +@@ -883,7 +883,7 @@ auto flat_tree& key_ref = key; + + KeyValueCompare key_value(impl_.get_key_comp()); +- return std::lower_bound(begin(), end(), key_ref, key_value); ++ return ranges::lower_bound(*this, key_ref, key_value); + } + + template +@@ -904,7 +904,7 @@ auto flat_tree& key_ref = key; + + KeyValueCompare key_value(impl_.get_key_comp()); +- return std::upper_bound(begin(), end(), key_ref, key_value); ++ return ranges::upper_bound(*this, key_ref, key_value); + } + + // ---------------------------------------------------------------------------- +@@ -978,7 +978,7 @@ size_t EraseIf( + base::internal::flat_tree& + container, + Predicate pred) { +- auto it = std::remove_if(container.begin(), container.end(), pred); ++ auto it = ranges::remove_if(container, pred); + size_t removed = std::distance(it, container.end()); + container.erase(it, container.end()); + return removed; +diff -up chromium-86.0.4240.75/base/containers/flat_tree_unittest.cc.a61fb57e chromium-86.0.4240.75/base/containers/flat_tree_unittest.cc +--- chromium-86.0.4240.75/base/containers/flat_tree_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/flat_tree_unittest.cc 2020-10-21 16:38:29.004091339 -0400 +@@ -35,6 +35,7 @@ + #include + #include + ++#include "base/ranges/algorithm.h" + #include "base/template_util.h" + #include "base/test/move_only_int.h" + #include "testing/gmock/include/gmock/gmock.h" +@@ -218,8 +219,8 @@ TEST(FlatTree, Stability) { + Tree cont({{0, 0}, {1, 0}, {0, 1}, {2, 0}, {0, 2}, {1, 1}}); + + auto AllOfSecondsAreZero = [&cont] { +- return std::all_of(cont.begin(), cont.end(), +- [](const Pair& elem) { return elem.second == 0; }); ++ return ranges::all_of(cont, ++ [](const Pair& elem) { return elem.second == 0; }); + }; + + EXPECT_TRUE(AllOfSecondsAreZero()) << "constructor should be stable"; +@@ -975,11 +976,11 @@ TEST(FlatTree, EraseEndDeath) { + TEST(FlatTree, KeyComp) { + ReversedTree cont({1, 2, 3, 4, 5}); + +- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.key_comp())); ++ EXPECT_TRUE(ranges::is_sorted(cont, cont.key_comp())); + int new_elements[] = {6, 7, 8, 9, 10}; + std::copy(std::begin(new_elements), std::end(new_elements), + std::inserter(cont, cont.end())); +- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.key_comp())); ++ EXPECT_TRUE(ranges::is_sorted(cont, cont.key_comp())); + } + + // value_compare value_comp() const +@@ -987,11 +988,11 @@ TEST(FlatTree, KeyComp) { + TEST(FlatTree, ValueComp) { + ReversedTree cont({1, 2, 3, 4, 5}); + +- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.value_comp())); ++ EXPECT_TRUE(ranges::is_sorted(cont, cont.value_comp())); + int new_elements[] = {6, 7, 8, 9, 10}; + std::copy(std::begin(new_elements), std::end(new_elements), + std::inserter(cont, cont.end())); +- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.value_comp())); ++ EXPECT_TRUE(ranges::is_sorted(cont, cont.value_comp())); + } + + // ---------------------------------------------------------------------------- +diff -up chromium-86.0.4240.75/base/containers/span_unittest.cc.a61fb57e chromium-86.0.4240.75/base/containers/span_unittest.cc +--- chromium-86.0.4240.75/base/containers/span_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/span_unittest.cc 2020-10-21 16:38:29.004091339 -0400 +@@ -6,7 +6,6 @@ + + #include + +-#include + #include + #include + #include +@@ -14,6 +13,7 @@ + #include + + #include "base/containers/checked_iterators.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/string_piece.h" + #include "testing/gmock/include/gmock/gmock.h" +@@ -1382,7 +1382,7 @@ TEST(SpanTest, Sort) { + int array[] = {5, 4, 3, 2, 1}; + + span dynamic_span = array; +- std::sort(dynamic_span.begin(), dynamic_span.end()); ++ ranges::sort(dynamic_span); + EXPECT_THAT(array, ElementsAre(1, 2, 3, 4, 5)); + std::sort(dynamic_span.rbegin(), dynamic_span.rend()); + EXPECT_THAT(array, ElementsAre(5, 4, 3, 2, 1)); +@@ -1390,7 +1390,7 @@ TEST(SpanTest, Sort) { + span static_span = array; + std::sort(static_span.rbegin(), static_span.rend(), std::greater<>()); + EXPECT_THAT(array, ElementsAre(1, 2, 3, 4, 5)); +- std::sort(static_span.begin(), static_span.end(), std::greater<>()); ++ ranges::sort(static_span, std::greater<>()); + EXPECT_THAT(array, ElementsAre(5, 4, 3, 2, 1)); + } + +diff -up chromium-86.0.4240.75/base/containers/unique_ptr_adapters_unittest.cc.a61fb57e chromium-86.0.4240.75/base/containers/unique_ptr_adapters_unittest.cc +--- chromium-86.0.4240.75/base/containers/unique_ptr_adapters_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/containers/unique_ptr_adapters_unittest.cc 2020-10-21 16:38:29.004091339 -0400 +@@ -4,10 +4,10 @@ + + #include "base/containers/unique_ptr_adapters.h" + +-#include + #include + #include + ++#include "base/ranges/algorithm.h" + #include "testing/gtest/include/gtest/gtest.h" + + namespace base { +@@ -76,19 +76,19 @@ TEST(UniquePtrMatcherTest, Basic) { + v.push_back(std::move(foo_ptr2)); + + { +- auto iter = std::find_if(v.begin(), v.end(), UniquePtrMatcher(foo1)); ++ auto iter = ranges::find_if(v, UniquePtrMatcher(foo1)); + ASSERT_TRUE(iter != v.end()); + EXPECT_EQ(foo1, iter->get()); + } + + { +- auto iter = std::find_if(v.begin(), v.end(), UniquePtrMatcher(foo2)); ++ auto iter = ranges::find_if(v, UniquePtrMatcher(foo2)); + ASSERT_TRUE(iter != v.end()); + EXPECT_EQ(foo2, iter->get()); + } + + { +- auto iter = std::find_if(v.begin(), v.end(), MatchesUniquePtr(foo2)); ++ auto iter = ranges::find_if(v, MatchesUniquePtr(foo2)); + ASSERT_TRUE(iter != v.end()); + EXPECT_EQ(foo2, iter->get()); + } +@@ -110,22 +110,19 @@ TEST(UniquePtrMatcherTest, Deleter) { + v.push_back(std::move(foo_ptr2)); + + { +- auto iter = std::find_if(v.begin(), v.end(), +- UniquePtrMatcher(foo1)); ++ auto iter = ranges::find_if(v, UniquePtrMatcher(foo1)); + ASSERT_TRUE(iter != v.end()); + EXPECT_EQ(foo1, iter->get()); + } + + { +- auto iter = std::find_if(v.begin(), v.end(), +- UniquePtrMatcher(foo2)); ++ auto iter = ranges::find_if(v, UniquePtrMatcher(foo2)); + ASSERT_TRUE(iter != v.end()); + EXPECT_EQ(foo2, iter->get()); + } + + { +- auto iter = std::find_if(v.begin(), v.end(), +- MatchesUniquePtr(foo2)); ++ auto iter = ranges::find_if(v, MatchesUniquePtr(foo2)); + ASSERT_TRUE(iter != v.end()); + EXPECT_EQ(foo2, iter->get()); + } +diff -up chromium-86.0.4240.75/base/debug/activity_analyzer.cc.a61fb57e chromium-86.0.4240.75/base/debug/activity_analyzer.cc +--- chromium-86.0.4240.75/base/debug/activity_analyzer.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/debug/activity_analyzer.cc 2020-10-21 16:38:29.004091339 -0400 +@@ -4,7 +4,6 @@ + + #include "base/debug/activity_analyzer.h" + +-#include + #include + + #include "base/check_op.h" +@@ -14,6 +13,7 @@ + #include "base/metrics/histogram_functions.h" + #include "base/metrics/histogram_macros.h" + #include "base/no_destructor.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/string_util.h" + +@@ -398,7 +398,7 @@ void GlobalActivityAnalyzer::PrepareAllA + } + + // Reverse the list of PIDs so that they get popped in the order found. +- std::reverse(process_ids_.begin(), process_ids_.end()); ++ ranges::reverse(process_ids_); + } + + } // namespace debug +diff -up chromium-86.0.4240.75/base/debug/task_trace.cc.a61fb57e chromium-86.0.4240.75/base/debug/task_trace.cc +--- chromium-86.0.4240.75/base/debug/task_trace.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/debug/task_trace.cc 2020-10-21 16:38:29.004091339 -0400 +@@ -4,13 +4,13 @@ + + #include "base/debug/task_trace.h" + ++#include "base/ranges/algorithm.h" + #include "build/build_config.h" + + #if defined(OS_ANDROID) + #include + #endif // OS_ANDROID + +-#include + #include + #include + +@@ -55,8 +55,7 @@ TaskTrace::TaskTrace() { + return; + std::array task_trace; + task_trace[0] = current_task->posted_from.program_counter(); +- std::copy(current_task->task_backtrace.begin(), +- current_task->task_backtrace.end(), task_trace.begin() + 1); ++ ranges::copy(current_task->task_backtrace, task_trace.begin() + 1); + size_t length = 0; + while (length < task_trace.size() && task_trace[length]) + ++length; +diff -up chromium-86.0.4240.75/base/feature_list_unittest.cc.a61fb57e chromium-86.0.4240.75/base/feature_list_unittest.cc +--- chromium-86.0.4240.75/base/feature_list_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/feature_list_unittest.cc 2020-10-21 16:38:29.005091348 -0400 +@@ -6,7 +6,6 @@ + + #include + +-#include + #include + #include + +@@ -14,6 +13,7 @@ + #include "base/memory/read_only_shared_memory_region.h" + #include "base/metrics/field_trial.h" + #include "base/metrics/persistent_memory_allocator.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/string_piece.h" + #include "base/strings/string_util.h" +@@ -39,7 +39,7 @@ struct Feature kFeatureOffByDefault { + std::string SortFeatureListString(const std::string& feature_list) { + std::vector features = + FeatureList::SplitFeatureListString(feature_list); +- std::sort(features.begin(), features.end()); ++ ranges::sort(features); + return JoinString(features, ","); + } + +diff -up chromium-86.0.4240.75/base/hash/sha1_perftest.cc.a61fb57e chromium-86.0.4240.75/base/hash/sha1_perftest.cc +--- chromium-86.0.4240.75/base/hash/sha1_perftest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/hash/sha1_perftest.cc 2020-10-21 16:38:29.005091348 -0400 +@@ -6,11 +6,11 @@ + + #include + #include +-#include + #include + #include + + #include "base/rand_util.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_number_conversions.h" + #include "base/strings/string_util.h" + #include "base/time/time.h" +@@ -48,7 +48,7 @@ void Timing(const size_t len) { + utime[i] = TimeTicks::Now() - start; + total_test_time += utime[i]; + } +- std::sort(utime.begin(), utime.end()); ++ ranges::sort(utime); + } + + reporter.AddResult(kMetricRuntime, total_test_time.InMicrosecondsF()); +@@ -67,8 +67,8 @@ void Timing(const size_t len) { + + // Convert to a comma-separated string so we can report every data point. + std::vector rate_strings(utime.size()); +- std::transform(utime.cbegin(), utime.cend(), rate_strings.begin(), +- [rate](const auto& t) { return NumberToString(rate(t)); }); ++ ranges::transform(utime, rate_strings.begin(), ++ [rate](const auto& t) { return NumberToString(rate(t)); }); + reporter.AddResultList(kMetricThroughput, JoinString(rate_strings, ",")); + } + +diff -up chromium-86.0.4240.75/base/i18n/break_iterator_unittest.cc.a61fb57e chromium-86.0.4240.75/base/i18n/break_iterator_unittest.cc +--- chromium-86.0.4240.75/base/i18n/break_iterator_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/i18n/break_iterator_unittest.cc 2020-10-21 16:38:29.005091348 -0400 +@@ -7,6 +7,7 @@ + #include + #include + ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/string_piece.h" + #include "base/strings/string_util.h" +@@ -414,8 +415,7 @@ TEST(BreakIteratorTest, IsSentenceBounda + sentence_breaks.push_back(24); + sentence_breaks.push_back(42); + for (size_t i = 0; i < str.size(); i++) { +- if (std::find(sentence_breaks.begin(), sentence_breaks.end(), i) != +- sentence_breaks.end()) { ++ if (ranges::find(sentence_breaks, i) != sentence_breaks.end()) { + EXPECT_TRUE(iter.IsSentenceBoundary(i)) << " at index=" << i; + } else { + EXPECT_FALSE(iter.IsSentenceBoundary(i)) << " at index=" << i; +diff -up chromium-86.0.4240.75/base/immediate_crash_unittest.cc.a61fb57e chromium-86.0.4240.75/base/immediate_crash_unittest.cc +diff -up chromium-86.0.4240.75/base/json/json_parser.cc.a61fb57e chromium-86.0.4240.75/base/json/json_parser.cc +--- chromium-86.0.4240.75/base/json/json_parser.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/json/json_parser.cc 2020-10-21 16:38:29.005091348 -0400 +@@ -13,6 +13,7 @@ + #include "base/macros.h" + #include "base/notreached.h" + #include "base/numerics/safe_conversions.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_number_conversions.h" + #include "base/strings/string_piece.h" + #include "base/strings/string_util.h" +@@ -441,7 +442,7 @@ Optional JSONParser::ConsumeDicti + ConsumeChar(); // Closing '}'. + // Reverse |dict_storage| to keep the last of elements with the same key in + // the input. +- std::reverse(dict_storage.begin(), dict_storage.end()); ++ ranges::reverse(dict_storage); + return Value(Value::DictStorage(std::move(dict_storage))); + } + +diff -up chromium-86.0.4240.75/base/memory/platform_shared_memory_region_unittest.cc.a61fb57e chromium-86.0.4240.75/base/memory/platform_shared_memory_region_unittest.cc +--- chromium-86.0.4240.75/base/memory/platform_shared_memory_region_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/memory/platform_shared_memory_region_unittest.cc 2020-10-21 16:38:29.005091348 -0400 +@@ -7,6 +7,7 @@ + #include "base/check.h" + #include "base/memory/shared_memory_mapping.h" + #include "base/process/process_metrics.h" ++#include "base/ranges/algorithm.h" + #include "base/system/sys_info.h" + #include "base/test/gtest_util.h" + #include "base/test/test_shared_memory_util.h" +@@ -250,11 +251,10 @@ void CheckReadOnlyMapProtection(void* ad + ASSERT_TRUE(base::debug::ReadProcMaps(&proc_maps)); + std::vector regions; + ASSERT_TRUE(base::debug::ParseProcMaps(proc_maps, ®ions)); +- auto it = +- std::find_if(regions.begin(), regions.end(), +- [addr](const base::debug::MappedMemoryRegion& region) { +- return region.start == reinterpret_cast(addr); +- }); ++ auto it = ranges::find_if( ++ regions, [addr](const base::debug::MappedMemoryRegion& region) { ++ return region.start == reinterpret_cast(addr); ++ }); + ASSERT_TRUE(it != regions.end()); + // PROT_READ may imply PROT_EXEC on some architectures, so just check that + // permissions don't contain PROT_WRITE bit. +diff -up chromium-86.0.4240.75/base/memory/shared_memory_mapping_unittest.cc.a61fb57e chromium-86.0.4240.75/base/memory/shared_memory_mapping_unittest.cc +--- chromium-86.0.4240.75/base/memory/shared_memory_mapping_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/memory/shared_memory_mapping_unittest.cc 2020-10-21 16:38:29.005091348 -0400 +@@ -6,12 +6,12 @@ + + #include + +-#include + #include + + #include "base/containers/span.h" + #include "base/memory/read_only_shared_memory_region.h" + #include "base/memory/writable_shared_memory_region.h" ++#include "base/ranges/algorithm.h" + #include "base/test/metrics/histogram_tester.h" + #include "build/build_config.h" + #include "testing/gmock/include/gmock/gmock.h" +@@ -67,7 +67,7 @@ TEST_F(SharedMemoryMappingTest, SpanWith + span read_span = read_mapping_.GetMemoryAsSpan(); + ASSERT_EQ(2u, read_span.size()); + +- std::fill(write_span.begin(), write_span.end(), 0); ++ ranges::fill(write_span, 0); + EXPECT_EQ(0u, read_span[0]); + EXPECT_EQ(0u, read_span[1]); + +@@ -92,7 +92,7 @@ TEST_F(SharedMemoryMappingTest, SpanWith + span read_span_2 = read_mapping_.GetMemoryAsSpan(1); + ASSERT_EQ(1u, read_span_2.size()); + +- std::fill(write_span.begin(), write_span.end(), 0); ++ ranges::fill(write_span, 0); + EXPECT_EQ(0u, read_span[0]); + EXPECT_EQ(0u, read_span[1]); + EXPECT_EQ(0u, read_span_2[0]); +@@ -103,7 +103,7 @@ TEST_F(SharedMemoryMappingTest, SpanWith + EXPECT_EQ(0x08070605u, read_span[1]); + EXPECT_EQ(0x04030201u, read_span_2[0]); + +- std::fill(write_span_2.begin(), write_span_2.end(), 0); ++ ranges::fill(write_span_2, 0); + EXPECT_EQ(0u, read_span[0]); + EXPECT_EQ(0x08070605u, read_span[1]); + EXPECT_EQ(0u, read_span_2[0]); +diff -up chromium-86.0.4240.75/base/metrics/histogram.cc.a61fb57e chromium-86.0.4240.75/base/metrics/histogram.cc +--- chromium-86.0.4240.75/base/metrics/histogram.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/metrics/histogram.cc 2020-10-21 16:38:29.006091357 -0400 +@@ -13,7 +13,6 @@ + #include + #include + +-#include + #include + #include + +@@ -29,6 +28,7 @@ + #include "base/metrics/sample_vector.h" + #include "base/metrics/statistics_recorder.h" + #include "base/pickle.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_util.h" + #include "base/strings/stringprintf.h" + #include "base/strings/utf_string_conversions.h" +@@ -1248,8 +1248,8 @@ class CustomHistogram::Factory : public + std::vector ranges = *custom_ranges_; + ranges.push_back(0); // Ensure we have a zero value. + ranges.push_back(HistogramBase::kSampleType_MAX); +- std::sort(ranges.begin(), ranges.end()); +- ranges.erase(std::unique(ranges.begin(), ranges.end()), ranges.end()); ++ ranges::sort(ranges); ++ ranges.erase(ranges::unique(ranges), ranges.end()); + + BucketRanges* bucket_ranges = new BucketRanges(ranges.size()); + for (uint32_t i = 0; i < ranges.size(); i++) { +diff -up chromium-86.0.4240.75/base/metrics/statistics_recorder.cc.a61fb57e chromium-86.0.4240.75/base/metrics/statistics_recorder.cc +--- chromium-86.0.4240.75/base/metrics/statistics_recorder.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/metrics/statistics_recorder.cc 2020-10-21 16:38:29.006091357 -0400 +@@ -16,6 +16,7 @@ + #include "base/metrics/metrics_hashes.h" + #include "base/metrics/persistent_histogram_allocator.h" + #include "base/metrics/record_histogram_checker.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/stringprintf.h" + #include "base/values.h" +@@ -366,7 +367,7 @@ StatisticsRecorder::Histograms Statistic + + // static + StatisticsRecorder::Histograms StatisticsRecorder::Sort(Histograms histograms) { +- std::sort(histograms.begin(), histograms.end(), &HistogramNameLesser); ++ ranges::sort(histograms, &HistogramNameLesser); + return histograms; + } + +@@ -376,12 +377,12 @@ StatisticsRecorder::Histograms Statistic + const std::string& query) { + // Need a C-string query for comparisons against C-string histogram name. + const char* const query_string = query.c_str(); +- histograms.erase(std::remove_if(histograms.begin(), histograms.end(), +- [query_string](const HistogramBase* const h) { +- return !strstr(h->histogram_name(), +- query_string); +- }), +- histograms.end()); ++ histograms.erase( ++ ranges::remove_if(histograms, ++ [query_string](const HistogramBase* const h) { ++ return !strstr(h->histogram_name(), query_string); ++ }), ++ histograms.end()); + return histograms; + } + +@@ -389,10 +390,11 @@ StatisticsRecorder::Histograms Statistic + StatisticsRecorder::Histograms StatisticsRecorder::NonPersistent( + Histograms histograms) { + histograms.erase( +- std::remove_if(histograms.begin(), histograms.end(), +- [](const HistogramBase* const h) { +- return (h->flags() & HistogramBase::kIsPersistent) != 0; +- }), ++ ranges::remove_if(histograms, ++ [](const HistogramBase* const h) { ++ return (h->flags() & HistogramBase::kIsPersistent) != ++ 0; ++ }), + histograms.end()); + return histograms; + } +diff -up chromium-86.0.4240.75/base/observer_list.h.a61fb57e chromium-86.0.4240.75/base/observer_list.h +--- chromium-86.0.4240.75/base/observer_list.h.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/observer_list.h 2020-10-21 16:44:23.777189648 -0400 +@@ -18,6 +18,7 @@ + #include "base/macros.h" + #include "base/notreached.h" + #include "base/observer_list_internal.h" ++#include "base/ranges/algorithm.h" + #include "base/sequence_checker.h" + #include "base/stl_util.h" + +@@ -279,9 +280,8 @@ class ObserverList { + // not in this list. + void RemoveObserver(const ObserverType* obs) { + DCHECK(obs); +- const auto it = +- std::find_if(observers_.begin(), observers_.end(), +- [obs](const auto& o) { return o.IsEqual(obs); }); ++ const auto it = ranges::find_if( ++ observers_, [obs](const auto& o) { return o.IsEqual(obs); }); + if (it == observers_.end()) + return; + +@@ -300,9 +300,9 @@ class ObserverList { + // probably DCHECK, but some client code currently does pass null. + if (obs == nullptr) + return false; +- return std::find_if(observers_.begin(), observers_.end(), +- [obs](const auto& o) { return o.IsEqual(obs); }) != +- observers_.end(); ++ return ranges::find_if(observers_, [obs](const auto& o) { ++ return o.IsEqual(obs); ++ }) != observers_.end(); + } + + // Removes all the observers from this list. +diff -up chromium-86.0.4240.75/base/process/process_metrics_unittest.cc.a61fb57e chromium-86.0.4240.75/base/process/process_metrics_unittest.cc +--- chromium-86.0.4240.75/base/process/process_metrics_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/process/process_metrics_unittest.cc 2020-10-21 16:38:29.006091357 -0400 +@@ -19,6 +19,7 @@ + #include "base/macros.h" + #include "base/memory/shared_memory_mapping.h" + #include "base/memory/writable_shared_memory_region.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_number_conversions.h" + #include "base/strings/string_util.h" + #include "base/strings/stringprintf.h" +@@ -781,13 +782,13 @@ TEST(ProcessMetricsTestLinux, GetCumulat + + // Should have at least the test runner thread and the thread spawned above. + EXPECT_GE(prev_thread_times.size(), 2u); +- EXPECT_TRUE(std::any_of( +- prev_thread_times.begin(), prev_thread_times.end(), ++ EXPECT_TRUE(ranges::any_of( ++ prev_thread_times, + [&thread1](const std::pair& entry) { + return entry.first == thread1.GetThreadId(); + })); +- EXPECT_TRUE(std::any_of( +- prev_thread_times.begin(), prev_thread_times.end(), ++ EXPECT_TRUE(ranges::any_of( ++ prev_thread_times, + [](const std::pair& entry) { + return entry.first == base::PlatformThread::CurrentId(); + })); +@@ -803,16 +804,16 @@ TEST(ProcessMetricsTestLinux, GetCumulat + + // The stopped thread may still be reported until the kernel cleans it up. + EXPECT_GE(prev_thread_times.size(), 1u); +- EXPECT_TRUE(std::any_of( +- current_thread_times.begin(), current_thread_times.end(), ++ EXPECT_TRUE(ranges::any_of( ++ current_thread_times, + [](const std::pair& entry) { + return entry.first == base::PlatformThread::CurrentId(); + })); + + // Reported times should not decrease. + for (const auto& entry : current_thread_times) { +- auto prev_it = std::find_if( +- prev_thread_times.begin(), prev_thread_times.end(), ++ auto prev_it = ranges::find_if( ++ prev_thread_times, + [&entry]( + const std::pair& prev_entry) { + return entry.first == prev_entry.first; +@@ -862,8 +863,8 @@ TEST(ProcessMetricsTestLinux, GetPerThre + + // Reported times should not decrease. + for (const auto& entry : current_thread_times) { +- auto prev_it = std::find_if( +- prev_thread_times.begin(), prev_thread_times.end(), ++ auto prev_it = ranges::find_if( ++ prev_thread_times, + [&entry](const ProcessMetrics::ThreadTimeInState& prev_entry) { + return entry.thread_id == prev_entry.thread_id && + entry.core_type == prev_entry.core_type && +diff -up chromium-86.0.4240.75/base/profiler/arm_cfi_table.cc.a61fb57e chromium-86.0.4240.75/base/profiler/arm_cfi_table.cc +--- chromium-86.0.4240.75/base/profiler/arm_cfi_table.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/profiler/arm_cfi_table.cc 2020-10-21 16:38:29.006091357 -0400 +@@ -4,7 +4,7 @@ + + #include "base/profiler/arm_cfi_table.h" + +-#include ++#include "base/ranges/algorithm.h" + + namespace base { + +@@ -91,8 +91,7 @@ Optional ArmCFI + // Find the required function address in UNW_INDEX as the last function lower + // or equal to |address| (the value right before the result of upper_bound(), + // if any). +- auto func_it = std::upper_bound(function_addresses_.begin(), +- function_addresses_.end(), address); ++ auto func_it = ranges::upper_bound(function_addresses_, address); + // If no function comes before |address|, no CFI entry is returned. + if (func_it == function_addresses_.begin()) + return nullopt; +@@ -157,4 +156,4 @@ Optional ArmCFI + return last_frame_entry; + } + +-} // namespace base +\ No newline at end of file ++} // namespace base +diff -up chromium-86.0.4240.75/base/profiler/metadata_recorder_unittest.cc.a61fb57e chromium-86.0.4240.75/base/profiler/metadata_recorder_unittest.cc +--- chromium-86.0.4240.75/base/profiler/metadata_recorder_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/profiler/metadata_recorder_unittest.cc 2020-10-21 16:38:29.006091357 -0400 +@@ -4,6 +4,7 @@ + + #include "base/profiler/metadata_recorder.h" + ++#include "base/ranges/algorithm.h" + #include "base/test/gtest_util.h" + #include "base/test/metrics/histogram_tester.h" + #include "testing/gmock/include/gmock/gmock.h" +@@ -213,7 +214,7 @@ TEST(MetadataRecorderTest, ReclaimInacti + } + + MetadataRecorder::ItemArray items_arr; +- std::copy(items_set.begin(), items_set.end(), items_arr.begin()); ++ ranges::copy(items_set, items_arr.begin()); + + MetadataRecorder::ItemArray recorder_items; + size_t recorder_item_count = +diff -up chromium-86.0.4240.75/base/profiler/module_cache.cc.a61fb57e chromium-86.0.4240.75/base/profiler/module_cache.cc +--- chromium-86.0.4240.75/base/profiler/module_cache.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/profiler/module_cache.cc 2020-10-21 16:38:29.007091366 -0400 +@@ -4,10 +4,11 @@ + + #include "base/profiler/module_cache.h" + +-#include + #include + #include + ++#include "base/ranges/algorithm.h" ++ + namespace base { + + namespace { +diff -up chromium-86.0.4240.75/base/profiler/stack_sampler_impl.cc.a61fb57e chromium-86.0.4240.75/base/profiler/stack_sampler_impl.cc +--- chromium-86.0.4240.75/base/profiler/stack_sampler_impl.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/profiler/stack_sampler_impl.cc 2020-10-21 16:38:29.007091366 -0400 +@@ -16,6 +16,7 @@ + #include "base/profiler/stack_copier.h" + #include "base/profiler/suspendable_thread_delegate.h" + #include "base/profiler/unwinder.h" ++#include "base/ranges/algorithm.h" + #include "build/build_config.h" + + // IMPORTANT NOTE: Some functions within this implementation are invoked while +@@ -161,11 +162,10 @@ std::vector StackSamplerImpl::Wal + do { + // Choose an authoritative unwinder for the current module. Use the first + // unwinder that thinks it can unwind from the current frame. +- auto unwinder = +- std::find_if(unwinders.begin(), unwinders.end(), +- [&stack](const std::unique_ptr& unwinder) { +- return unwinder->CanUnwindFrom(stack.back()); +- }); ++ auto unwinder = ranges::find_if( ++ unwinders, [&stack](const std::unique_ptr& unwinder) { ++ return unwinder->CanUnwindFrom(stack.back()); ++ }); + if (unwinder == unwinders.end()) + return stack; + +diff -up chromium-86.0.4240.75/base/profiler/stack_sampling_profiler_unittest.cc.a61fb57e chromium-86.0.4240.75/base/profiler/stack_sampling_profiler_unittest.cc +--- chromium-86.0.4240.75/base/profiler/stack_sampling_profiler_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/profiler/stack_sampling_profiler_unittest.cc 2020-10-21 16:38:29.007091366 -0400 +@@ -5,7 +5,6 @@ + #include + #include + +-#include + #include + #include + #include +@@ -25,6 +24,7 @@ + #include "base/profiler/stack_sampling_profiler.h" + #include "base/profiler/stack_sampling_profiler_test_util.h" + #include "base/profiler/unwinder.h" ++#include "base/ranges/algorithm.h" + #include "base/run_loop.h" + #include "base/scoped_native_library.h" + #include "base/stl_util.h" +@@ -269,10 +269,10 @@ size_t WaitForSamplingComplete( + const std::vector>& infos) { + // Map unique_ptrs to something that WaitMany can accept. + std::vector sampling_completed_rawptrs(infos.size()); +- std::transform(infos.begin(), infos.end(), sampling_completed_rawptrs.begin(), +- [](const std::unique_ptr& info) { +- return &info.get()->completed; +- }); ++ ranges::transform(infos, sampling_completed_rawptrs.begin(), ++ [](const std::unique_ptr& info) { ++ return &info.get()->completed; ++ }); + // Wait for one profiler to finish. + return WaitableEvent::WaitMany(sampling_completed_rawptrs.data(), + sampling_completed_rawptrs.size()); +diff -up chromium-86.0.4240.75/base/sampling_heap_profiler/poisson_allocation_sampler.cc.a61fb57e chromium-86.0.4240.75/base/sampling_heap_profiler/poisson_allocation_sampler.cc +--- chromium-86.0.4240.75/base/sampling_heap_profiler/poisson_allocation_sampler.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/sampling_heap_profiler/poisson_allocation_sampler.cc 2020-10-21 16:38:29.007091366 -0400 +@@ -4,7 +4,6 @@ + + #include "base/sampling_heap_profiler/poisson_allocation_sampler.h" + +-#include + #include + #include + #include +@@ -17,6 +16,7 @@ + #include "base/no_destructor.h" + #include "base/partition_alloc_buildflags.h" + #include "base/rand_util.h" ++#include "base/ranges/algorithm.h" + #include "build/build_config.h" + + #if defined(OS_APPLE) || defined(OS_ANDROID) +@@ -557,8 +557,7 @@ void PoissonAllocationSampler::SuppressR + void PoissonAllocationSampler::AddSamplesObserver(SamplesObserver* observer) { + ScopedMuteThreadSamples no_reentrancy_scope; + AutoLock lock(mutex_); +- DCHECK(std::find(observers_.begin(), observers_.end(), observer) == +- observers_.end()); ++ DCHECK(ranges::find(observers_, observer) == observers_.end()); + observers_.push_back(observer); + InstallAllocatorHooksOnce(); + g_running = !observers_.empty(); +@@ -568,7 +567,7 @@ void PoissonAllocationSampler::RemoveSam + SamplesObserver* observer) { + ScopedMuteThreadSamples no_reentrancy_scope; + AutoLock lock(mutex_); +- auto it = std::find(observers_.begin(), observers_.end(), observer); ++ auto it = ranges::find(observers_, observer); + DCHECK(it != observers_.end()); + observers_.erase(it); + g_running = !observers_.empty(); +diff -up chromium-86.0.4240.75/base/scoped_observer.h.a61fb57e chromium-86.0.4240.75/base/scoped_observer.h +--- chromium-86.0.4240.75/base/scoped_observer.h.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/scoped_observer.h 2020-10-21 16:47:44.604936721 -0400 +@@ -7,11 +7,11 @@ + + #include + +-#include + #include + + #include "base/check.h" + #include "base/macros.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + + // ScopedObserver is used to keep track of the set of sources an object has +@@ -56,7 +56,7 @@ class ScopedObserver { + + // Remove the object passed to the constructor as an observer from |source|. + void Remove(Source* source) { +- auto it = std::find(sources_.begin(), sources_.end(), source); ++ auto it = base::ranges::find(sources_, source); + DCHECK(it != sources_.end()); + sources_.erase(it); + (source->*RemoveObsFn)(observer_); +diff -up chromium-86.0.4240.75/base/strings/abseil_string_conversions.cc.a61fb57e chromium-86.0.4240.75/base/strings/abseil_string_conversions.cc +--- chromium-86.0.4240.75/base/strings/abseil_string_conversions.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/strings/abseil_string_conversions.cc 2020-10-21 16:38:29.007091366 -0400 +@@ -4,10 +4,10 @@ + + #include "base/strings/abseil_string_conversions.h" + +-#include + #include + + #include "base/containers/span.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_piece.h" + #include "third_party/abseil-cpp/absl/strings/string_view.h" + +@@ -16,16 +16,14 @@ namespace base { + std::vector StringPiecesToStringViews( + span pieces) { + std::vector views(pieces.size()); +- std::transform(pieces.begin(), pieces.end(), views.begin(), +- &StringPieceToStringView); ++ ranges::transform(pieces, views.begin(), &StringPieceToStringView); + return views; + } + + std::vector StringViewsToStringPieces( + span views) { + std::vector pieces(views.size()); +- std::transform(views.begin(), views.end(), pieces.begin(), +- &StringViewToStringPiece); ++ ranges::transform(views, pieces.begin(), &StringViewToStringPiece); + return pieces; + } + +diff -up chromium-86.0.4240.75/base/strings/string_util_internal.h.a61fb57e chromium-86.0.4240.75/base/strings/string_util_internal.h +--- chromium-86.0.4240.75/base/strings/string_util_internal.h.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/strings/string_util_internal.h 2020-10-21 16:38:29.007091366 -0400 +@@ -7,6 +7,7 @@ + + #include "base/logging.h" + #include "base/notreached.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_piece.h" + #include "base/third_party/icu/icu_utf.h" + +@@ -578,8 +579,7 @@ StringType DoReplaceStringPlaceholders( + ReplacementOffset r_offset(index, + static_cast(formatted.size())); + r_offsets.insert( +- std::upper_bound(r_offsets.begin(), r_offsets.end(), r_offset, +- &CompareParameter), ++ ranges::upper_bound(r_offsets, r_offset, &CompareParameter), + r_offset); + } + if (index < substitutions) +diff -up chromium-86.0.4240.75/base/synchronization/waitable_event_posix.cc.a61fb57e chromium-86.0.4240.75/base/synchronization/waitable_event_posix.cc +--- chromium-86.0.4240.75/base/synchronization/waitable_event_posix.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/synchronization/waitable_event_posix.cc 2020-10-21 16:38:29.008091375 -0400 +@@ -4,13 +4,13 @@ + + #include + +-#include + #include + #include + + #include "base/check_op.h" + #include "base/debug/activity_tracker.h" + #include "base/optional.h" ++#include "base/ranges/algorithm.h" + #include "base/synchronization/condition_variable.h" + #include "base/synchronization/lock.h" + #include "base/synchronization/waitable_event.h" +@@ -265,7 +265,7 @@ size_t WaitableEvent::WaitMany(WaitableE + + DCHECK_EQ(count, waitables.size()); + +- sort(waitables.begin(), waitables.end(), cmp_fst_addr); ++ ranges::sort(waitables, cmp_fst_addr); + + // The set of waitables must be distinct. Since we have just sorted by + // address, we can check this cheaply by comparing pairs of consecutive +diff -up chromium-86.0.4240.75/base/task/common/checked_lock_impl.cc.a61fb57e chromium-86.0.4240.75/base/task/common/checked_lock_impl.cc +--- chromium-86.0.4240.75/base/task/common/checked_lock_impl.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/common/checked_lock_impl.cc 2020-10-21 16:38:29.008091375 -0400 +@@ -4,12 +4,12 @@ + + #include "base/task/common/checked_lock_impl.h" + +-#include + #include + #include + + #include "base/check_op.h" + #include "base/lazy_instance.h" ++#include "base/ranges/algorithm.h" + #include "base/synchronization/condition_variable.h" + #include "base/task/common/checked_lock.h" + #include "base/threading/platform_thread.h" +@@ -44,8 +44,7 @@ class SafeAcquisitionTracker { + + void RecordRelease(const CheckedLockImpl* const lock) { + LockVector* acquired_locks = GetAcquiredLocksOnCurrentThread(); +- const auto iter_at_lock = +- std::find(acquired_locks->begin(), acquired_locks->end(), lock); ++ const auto iter_at_lock = ranges::find(*acquired_locks, lock); + DCHECK(iter_at_lock != acquired_locks->end()); + acquired_locks->erase(iter_at_lock); + } +diff -up chromium-86.0.4240.75/base/task/common/operations_controller_unittest.cc.a61fb57e chromium-86.0.4240.75/base/task/common/operations_controller_unittest.cc +--- chromium-86.0.4240.75/base/task/common/operations_controller_unittest.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/common/operations_controller_unittest.cc 2020-10-21 16:38:29.008091375 -0400 +@@ -8,6 +8,7 @@ + #include + #include + ++#include "base/ranges/algorithm.h" + #include "base/threading/platform_thread.h" + #include "base/threading/simple_thread.h" + #include "testing/gtest/include/gtest/gtest.h" +@@ -124,8 +125,7 @@ class TestThread : public SimpleThread { + } + if (!was_started) + continue; +- if (std::any_of(tokens.begin(), tokens.end(), +- [](const auto& token) { return !token; })) { ++ if (ranges::any_of(tokens, [](const auto& token) { return !token; })) { + break; + } + } +diff -up chromium-86.0.4240.75/base/task/common/task_annotator.cc.a61fb57e chromium-86.0.4240.75/base/task/common/task_annotator.cc +--- chromium-86.0.4240.75/base/task/common/task_annotator.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/common/task_annotator.cc 2020-10-21 16:48:17.376221810 -0400 +@@ -9,6 +9,7 @@ + #include "base/debug/activity_tracker.h" + #include "base/debug/alias.h" + #include "base/no_destructor.h" ++#include "base/ranges/algorithm.h" + #include "base/threading/thread_local.h" + #include "base/trace_event/base_tracing.h" + +@@ -127,8 +128,7 @@ void TaskAnnotator::RunTask(const char* + task_backtrace.back() = reinterpret_cast(0x0d00d1d1d178119); + + task_backtrace[1] = pending_task->posted_from.program_counter(); +- std::copy(pending_task->task_backtrace.begin(), +- pending_task->task_backtrace.end(), task_backtrace.begin() + 2); ++ ranges::copy(pending_task->task_backtrace, task_backtrace.begin() + 2); + task_backtrace[kStackTaskTraceSnapshotSize - 2] = + reinterpret_cast(pending_task->ipc_hash); + debug::Alias(&task_backtrace); +diff -up chromium-86.0.4240.75/base/task/sequence_manager/sequence_manager_impl.cc.a61fb57e chromium-86.0.4240.75/base/task/sequence_manager/sequence_manager_impl.cc +--- chromium-86.0.4240.75/base/task/sequence_manager/sequence_manager_impl.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/sequence_manager/sequence_manager_impl.cc 2020-10-21 16:38:29.008091375 -0400 +@@ -18,6 +18,7 @@ + #include "base/no_destructor.h" + #include "base/optional.h" + #include "base/rand_util.h" ++#include "base/ranges/algorithm.h" + #include "base/task/sequence_manager/real_time_domain.h" + #include "base/task/sequence_manager/task_time_observer.h" + #include "base/task/sequence_manager/thread_controller_impl.h" +@@ -539,8 +540,7 @@ void SequenceManagerImpl::LogTaskDebugIn + case Settings::TaskLogging::kEnabledWithBacktrace: { + std::array task_trace; + task_trace[0] = task->posted_from.program_counter(); +- std::copy(task->task_backtrace.begin(), task->task_backtrace.end(), +- task_trace.begin() + 1); ++ ranges::copy(task->task_backtrace, task_trace.begin() + 1); + size_t length = 0; + while (length < task_trace.size() && task_trace[length]) + ++length; +diff -up chromium-86.0.4240.75/base/task/sequence_manager/task_queue_impl.cc.a61fb57e chromium-86.0.4240.75/base/task/sequence_manager/task_queue_impl.cc +--- chromium-86.0.4240.75/base/task/sequence_manager/task_queue_impl.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/sequence_manager/task_queue_impl.cc 2020-10-21 16:38:29.008091375 -0400 +@@ -10,6 +10,7 @@ + #include + + #include "base/logging.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/stringprintf.h" + #include "base/task/common/scoped_defer_task_posting.h" + #include "base/task/sequence_manager/sequence_manager_impl.h" +@@ -1404,7 +1405,7 @@ void TaskQueueImpl::DelayedIncomingQueue + + // If we deleted something, re-enforce the heap property. + if (task_deleted) +- std::make_heap(queue_.c.begin(), queue_.c.end(), queue_.comp); ++ ranges::make_heap(queue_.c, queue_.comp); + } + + Value TaskQueueImpl::DelayedIncomingQueue::AsValue(TimeTicks now) const { +diff -up chromium-86.0.4240.75/base/task/thread_pool/pooled_single_thread_task_runner_manager.cc.a61fb57e chromium-86.0.4240.75/base/task/thread_pool/pooled_single_thread_task_runner_manager.cc +--- chromium-86.0.4240.75/base/task/thread_pool/pooled_single_thread_task_runner_manager.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/thread_pool/pooled_single_thread_task_runner_manager.cc 2020-10-21 16:38:29.009091383 -0400 +@@ -4,7 +4,6 @@ + + #include "base/task/thread_pool/pooled_single_thread_task_runner_manager.h" + +-#include + #include + #include + #include +@@ -12,6 +11,7 @@ + #include "base/bind.h" + #include "base/callback.h" + #include "base/memory/ptr_util.h" ++#include "base/ranges/algorithm.h" + #include "base/single_thread_task_runner.h" + #include "base/stl_util.h" + #include "base/strings/stringprintf.h" +@@ -719,7 +719,7 @@ void PooledSingleThreadTaskRunnerManager + if (workers_.empty()) + return; + +- auto worker_iter = std::find(workers_.begin(), workers_.end(), worker); ++ auto worker_iter = ranges::find(workers_, worker); + DCHECK(worker_iter != workers_.end()); + worker_to_destroy = std::move(*worker_iter); + workers_.erase(worker_iter); +diff -up chromium-86.0.4240.75/base/task/thread_pool/thread_group_impl.cc.a61fb57e chromium-86.0.4240.75/base/task/thread_pool/thread_group_impl.cc +--- chromium-86.0.4240.75/base/task/thread_pool/thread_group_impl.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/thread_pool/thread_group_impl.cc 2020-10-21 16:38:29.009091383 -0400 +@@ -22,6 +22,7 @@ + #include "base/metrics/histogram.h" + #include "base/numerics/clamped_math.h" + #include "base/optional.h" ++#include "base/ranges/algorithm.h" + #include "base/sequence_token.h" + #include "base/strings/string_util.h" + #include "base/strings/stringprintf.h" +@@ -83,10 +84,10 @@ constexpr TimeDelta kBackgroundBlockedWo + // Only used in DCHECKs. + bool ContainsWorker(const std::vector>& workers, + const WorkerThread* worker) { +- auto it = std::find_if(workers.begin(), workers.end(), +- [worker](const scoped_refptr& i) { +- return i.get() == worker; +- }); ++ auto it = ++ ranges::find_if(workers, [worker](const scoped_refptr& i) { ++ return i.get() == worker; ++ }); + return it != workers.end(); + } + +@@ -734,8 +735,7 @@ void ThreadGroupImpl::WorkerThreadDelega + outer_->idle_workers_stack_.Remove(worker); + + // Remove the worker from |workers_|. +- auto worker_iter = +- std::find(outer_->workers_.begin(), outer_->workers_.end(), worker); ++ auto worker_iter = ranges::find(outer_->workers_, worker); + DCHECK(worker_iter != outer_->workers_.end()); + outer_->workers_.erase(worker_iter); + } +diff -up chromium-86.0.4240.75/base/task/thread_pool/worker_thread_stack.cc.a61fb57e chromium-86.0.4240.75/base/task/thread_pool/worker_thread_stack.cc +--- chromium-86.0.4240.75/base/task/thread_pool/worker_thread_stack.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/task/thread_pool/worker_thread_stack.cc 2020-10-21 16:38:29.009091383 -0400 +@@ -4,9 +4,8 @@ + + #include "base/task/thread_pool/worker_thread_stack.h" + +-#include +- + #include "base/check_op.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/task/thread_pool/worker_thread.h" + +@@ -47,7 +46,7 @@ bool WorkerThreadStack::Contains(const W + void WorkerThreadStack::Remove(const WorkerThread* worker) { + DCHECK(!IsEmpty()); + DCHECK_NE(worker, stack_.back()); +- auto it = std::find(stack_.begin(), stack_.end(), worker); ++ auto it = ranges::find(stack_, worker); + DCHECK(it != stack_.end()); + DCHECK_NE(TimeTicks(), (*it)->GetLastUsedTime()); + stack_.erase(it); +diff -up chromium-86.0.4240.75/base/test/launcher/test_launcher.cc.a61fb57e chromium-86.0.4240.75/base/test/launcher/test_launcher.cc +--- chromium-86.0.4240.75/base/test/launcher/test_launcher.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/test/launcher/test_launcher.cc 2020-10-21 16:38:29.009091383 -0400 +@@ -30,6 +30,7 @@ + #include "base/numerics/safe_conversions.h" + #include "base/process/kill.h" + #include "base/process/launch.h" ++#include "base/ranges/algorithm.h" + #include "base/run_loop.h" + #include "base/single_thread_task_runner.h" + #include "base/strings/pattern.h" +@@ -670,7 +671,7 @@ void TestRunner::Run(const std::vector + #include + #include + + #include "base/memory/ptr_util.h" + #include "base/metrics/field_trial_param_associator.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_number_conversions.h" + #include "base/strings/string_split.h" + #include "base/strings/string_util.h" +@@ -71,10 +71,10 @@ struct Features { + // with GetFeatureName() and also could be without parameters. + bool ContainsFeature(const std::vector& feature_vector, + StringPiece feature_name) { +- auto iter = std::find_if(feature_vector.begin(), feature_vector.end(), +- [&feature_name](const StringPiece& a) { +- return GetFeatureName(a) == feature_name; +- }); ++ auto iter = ++ ranges::find_if(feature_vector, [&feature_name](const StringPiece& a) { ++ return GetFeatureName(a) == feature_name; ++ }); + return iter != feature_vector.end(); + } + +diff -up chromium-86.0.4240.75/base/test/trace_event_analyzer.cc.a61fb57e chromium-86.0.4240.75/base/test/trace_event_analyzer.cc +--- chromium-86.0.4240.75/base/test/trace_event_analyzer.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/test/trace_event_analyzer.cc 2020-10-21 16:38:29.010091392 -0400 +@@ -14,6 +14,7 @@ + #include "base/logging.h" + #include "base/memory/ptr_util.h" + #include "base/memory/ref_counted_memory.h" ++#include "base/ranges/algorithm.h" + #include "base/run_loop.h" + #include "base/strings/pattern.h" + #include "base/trace_event/trace_buffer.h" +@@ -775,7 +776,7 @@ bool TraceAnalyzer::SetEvents(const std: + raw_events_.clear(); + if (!ParseEventsFromJson(json_events, &raw_events_)) + return false; +- std::stable_sort(raw_events_.begin(), raw_events_.end()); ++ base::ranges::stable_sort(raw_events_); + ParseMetadata(); + return true; + } +@@ -964,7 +965,7 @@ bool GetRateStats(const TraceEventVector + deltas.push_back(delta); + } + +- std::sort(deltas.begin(), deltas.end()); ++ base::ranges::sort(deltas); + + if (options) { + if (options->trim_min + options->trim_max > events.size() - kMinEvents) { +@@ -980,8 +981,8 @@ bool GetRateStats(const TraceEventVector + for (size_t i = 0; i < num_deltas; ++i) + delta_sum += deltas[i]; + +- stats->min_us = *std::min_element(deltas.begin(), deltas.end()); +- stats->max_us = *std::max_element(deltas.begin(), deltas.end()); ++ stats->min_us = *base::ranges::min_element(deltas); ++ stats->max_us = *base::ranges::max_element(deltas); + stats->mean_us = delta_sum / static_cast(num_deltas); + + double sum_mean_offsets_squared = 0.0; +diff -up chromium-86.0.4240.75/base/threading/hang_watcher.cc.a61fb57e chromium-86.0.4240.75/base/threading/hang_watcher.cc +--- chromium-86.0.4240.75/base/threading/hang_watcher.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/threading/hang_watcher.cc 2020-10-21 16:38:29.010091392 -0400 +@@ -4,7 +4,6 @@ + + #include "base/threading/hang_watcher.h" + +-#include + #include + #include + +@@ -16,6 +15,7 @@ + #include "base/feature_list.h" + #include "base/metrics/field_trial_params.h" + #include "base/no_destructor.h" ++#include "base/ranges/algorithm.h" + #include "base/strings/string_number_conversions.h" + #include "base/synchronization/lock.h" + #include "base/synchronization/waitable_event.h" +@@ -413,10 +413,10 @@ HangWatcher::WatchStateSnapShot::WatchSt + + // Sort |hung_watch_state_copies_| by order of decreasing hang severity so the + // most severe hang is first in the list. +- std::sort(hung_watch_state_copies_.begin(), hung_watch_state_copies_.end(), +- [](const WatchStateCopy& lhs, const WatchStateCopy& rhs) { +- return lhs.deadline < rhs.deadline; +- }); ++ ranges::sort(hung_watch_state_copies_, ++ [](const WatchStateCopy& lhs, const WatchStateCopy& rhs) { ++ return lhs.deadline < rhs.deadline; ++ }); + } + + HangWatcher::WatchStateSnapShot::WatchStateSnapShot( +@@ -476,8 +476,8 @@ void HangWatcher::Monitor() { + // atomically. This is fine. Detecting a hang is generally best effort and + // if a thread resumes from hang in the time it takes to move on to + // capturing then its ID will be absent from the crash keys. +- bool any_thread_hung = std::any_of( +- watch_states_.cbegin(), watch_states_.cend(), ++ bool any_thread_hung = ranges::any_of( ++ watch_states_, + [this, now](const std::unique_ptr& state) { + uint64_t flags; + base::TimeTicks deadline; +@@ -595,12 +595,12 @@ void HangWatcher::UnregisterThread() { + internal::HangWatchState* current_hang_watch_state = + internal::HangWatchState::GetHangWatchStateForCurrentThread()->Get(); + +- auto it = +- std::find_if(watch_states_.cbegin(), watch_states_.cend(), +- [current_hang_watch_state]( +- const std::unique_ptr& state) { +- return state.get() == current_hang_watch_state; +- }); ++ auto it = ranges::find_if( ++ watch_states_, ++ [current_hang_watch_state]( ++ const std::unique_ptr& state) { ++ return state.get() == current_hang_watch_state; ++ }); + + // Thread should be registered to get unregistered. + DCHECK(it != watch_states_.end()); +diff -up chromium-86.0.4240.75/base/trace_event/trace_log.cc.a61fb57e chromium-86.0.4240.75/base/trace_event/trace_log.cc +--- chromium-86.0.4240.75/base/trace_event/trace_log.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/trace_event/trace_log.cc 2020-10-21 16:38:29.010091392 -0400 +@@ -4,7 +4,6 @@ + + #include "base/trace_event/trace_log.h" + +-#include + #include + #include + #include +@@ -23,6 +22,7 @@ + #include "base/no_destructor.h" + #include "base/process/process.h" + #include "base/process/process_metrics.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/string_piece.h" + #include "base/strings/string_split.h" +@@ -777,8 +777,7 @@ void TraceLog::AddEnabledStateObserver(E + void TraceLog::RemoveEnabledStateObserver(EnabledStateObserver* listener) { + AutoLock lock(observers_lock_); + enabled_state_observers_.erase( +- std::remove(enabled_state_observers_.begin(), +- enabled_state_observers_.end(), listener), ++ ranges::remove(enabled_state_observers_, listener), + enabled_state_observers_.end()); + } + +diff -up chromium-86.0.4240.75/base/values.cc.a61fb57e chromium-86.0.4240.75/base/values.cc +--- chromium-86.0.4240.75/base/values.cc.a61fb57e 2020-10-07 12:38:34.000000000 -0400 ++++ chromium-86.0.4240.75/base/values.cc 2020-10-21 16:38:29.010091392 -0400 +@@ -6,7 +6,6 @@ + + #include + +-#include + #include + #include + #include +@@ -18,6 +17,7 @@ + #include "base/json/json_writer.h" + #include "base/memory/ptr_util.h" + #include "base/notreached.h" ++#include "base/ranges/algorithm.h" + #include "base/stl_util.h" + #include "base/strings/string_util.h" + #include "base/strings/utf_string_conversions.h" +@@ -1581,7 +1581,7 @@ bool ListValue::Remove(size_t index, std + } + + bool ListValue::Remove(const Value& value, size_t* index) { +- auto it = std::find(list().begin(), list().end(), value); ++ auto it = ranges::find(list(), value); + + if (it == list().end()) + return false; +@@ -1659,7 +1659,7 @@ bool ListValue::Insert(size_t index, std + } + + ListValue::const_iterator ListValue::Find(const Value& value) const { +- return std::find(GetList().begin(), GetList().end(), value); ++ return ranges::find(GetList(), value); + } + + void ListValue::Swap(ListValue* other) { +diff -up chromium-86.0.4240.75/content/public/browser/content_browser_client.cc.a61fb57e chromium-86.0.4240.75/content/public/browser/content_browser_client.cc +--- chromium-86.0.4240.75/content/public/browser/content_browser_client.cc.a61fb57e 2020-10-21 16:38:29.011091401 -0400 ++++ chromium-86.0.4240.75/content/public/browser/content_browser_client.cc 2020-10-21 16:48:43.858452175 -0400 +@@ -9,7 +9,7 @@ + // declarations instead of including more headers. If that is infeasible, adjust + // the limit. For more info, see + // https://chromium.googlesource.com/chromium/src/+/HEAD/docs/wmax_tokens.md +-#pragma clang max_tokens_here 880000 ++#pragma clang max_tokens_here 910000 + + #include + +diff -up chromium-86.0.4240.75/third_party/blink/renderer/core/dom/document.cc.a61fb57e chromium-86.0.4240.75/third_party/blink/renderer/core/dom/document.cc +--- chromium-86.0.4240.75/third_party/blink/renderer/core/dom/document.cc.a61fb57e 2020-10-21 16:38:29.013091419 -0400 ++++ chromium-86.0.4240.75/third_party/blink/renderer/core/dom/document.cc 2020-10-21 16:49:03.209620502 -0400 +@@ -33,7 +33,7 @@ + // instead of including more headers. If that is infeasible, adjust the limit. + // For more info, see + // https://chromium.googlesource.com/chromium/src/+/HEAD/docs/wmax_tokens.md +-#pragma clang max_tokens_here 900000 ++#pragma clang max_tokens_here 960000 + + #include + #include diff --git a/chromium-87-CursorFactory-include.patch b/chromium-87-CursorFactory-include.patch new file mode 100644 index 0000000..98cb9cf --- /dev/null +++ b/chromium-87-CursorFactory-include.patch @@ -0,0 +1,36 @@ +From c4f6e8cd34a245c3640b86a91c9694d69594d80b Mon Sep 17 00:00:00 2001 +From: Stephan Hartmann +Date: Wed, 16 Sep 2020 15:05:02 +0000 +Subject: [PATCH] IWYU: ui::CursorFactory is now required independent from + Ozone + +--- + .../ui/views/chrome_browser_main_extra_parts_views_linux.cc | 5 +---- + 1 file changed, 1 insertion(+), 4 deletions(-) + +diff --git a/chrome/browser/ui/views/chrome_browser_main_extra_parts_views_linux.cc b/chrome/browser/ui/views/chrome_browser_main_extra_parts_views_linux.cc +index 5a97d61..ccedd2a 100644 +--- a/chrome/browser/ui/views/chrome_browser_main_extra_parts_views_linux.cc ++++ b/chrome/browser/ui/views/chrome_browser_main_extra_parts_views_linux.cc +@@ -7,6 +7,7 @@ + #include "chrome/browser/themes/theme_service_aura_linux.h" + #include "chrome/browser/ui/browser_list.h" + #include "chrome/browser/ui/views/theme_profile_key.h" ++#include "ui/base/cursor/cursor_factory.h" + #include "ui/display/screen.h" + #include "ui/views/linux_ui/linux_ui.h" + +@@ -15,10 +16,6 @@ + #include "ui/gtk/gtk_ui_delegate.h" + #endif + +-#if defined(USE_OZONE) +-#include "ui/base/cursor/cursor_factory.h" +-#endif +- + #if defined(USE_X11) + #include "ui/gfx/x/connection.h" // nogncheck + #if BUILDFLAG(USE_GTK) +-- +2.26.2 + diff --git a/chromium-87-openscreen-include.patch b/chromium-87-openscreen-include.patch new file mode 100644 index 0000000..42545a8 --- /dev/null +++ b/chromium-87-openscreen-include.patch @@ -0,0 +1,25 @@ +From 0c0af4cabb7490db473cd2c28f069956974a4d98 Mon Sep 17 00:00:00 2001 +From: Stephan Hartmann +Date: Fri, 2 Oct 2020 12:11:58 +0000 +Subject: [PATCH] IWYU: uint8_t is defined in stdint.h + +--- + third_party/openscreen/src/util/crypto/random_bytes.h | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/third_party/openscreen/src/util/crypto/random_bytes.h b/third_party/openscreen/src/util/crypto/random_bytes.h +index 3cb2fa8..025b52c 100644 +--- a/third_party/openscreen/src/util/crypto/random_bytes.h ++++ b/third_party/openscreen/src/util/crypto/random_bytes.h +@@ -7,6 +7,8 @@ + + #include + ++#include ++ + namespace openscreen { + + std::array GenerateRandomBytes16(); +-- +2.26.2 + diff --git a/chromium.spec b/chromium.spec index 72bcd7d..08b7d05 100644 --- a/chromium.spec +++ b/chromium.spec @@ -184,8 +184,8 @@ Name: chromium%{chromium_channel}%{nsuffix} %else Name: chromium%{chromium_channel} %endif -Version: %{majorversion}.0.4240.75 -Release: 2%{?dist} +Version: %{majorversion}.0.4240.111 +Release: 1%{?dist} %if %{?freeworld} %if %{?shared} # chromium-libs-media-freeworld @@ -275,6 +275,9 @@ Patch70: chromium-84.0.4147.125-i686-fix_textrels.patch Patch71: chromium-84.0.4147.125-aarch64-clearkeycdm-binutils-workaround.patch # https://github.com/chromium/chromium/commit/53478caee862624fc6d73516f8d64253854b146f Patch72: chromium-85.0.4183.102-invalid-end-CookieMonster-53478ca.patch +# EL7 failed to compile without this, but it seems accurate for all branches +# https://github.com/chromium/chromium/commit/a61fb57edb75fcfe251af0e6f66820d13924ad62 +Patch73: chromium-86-use-range-based-algorithms.patch # Use lstdc++ on EPEL7 only Patch101: chromium-75.0.3770.100-epel7-stdc++.patch @@ -892,6 +895,7 @@ udev. %patch70 -p1 -b .i686-textrels %patch71 -p1 -b .aarch64-clearkeycdm-binutils-workaround %patch72 -p1 -b .invalid-end-CookieMonster +%patch73 -p1 -b .a61fb57e # Fedora branded user agent %if 0%{?fedora} @@ -1921,6 +1925,9 @@ getent group chrome-remote-desktop >/dev/null || groupadd -r chrome-remote-deskt %changelog +* Wed Oct 21 2020 Tom Callaway - 86.0.4240.111-1 +- update to 86.0.4240.111 + * Tue Oct 20 2020 Tom Callaway - 86.0.4240.75-2 - use bundled zlib/minizip on el7 (thanks Red Hat. :P) diff --git a/sources b/sources index 3acfc8f..53c9299 100644 --- a/sources +++ b/sources @@ -20,4 +20,4 @@ SHA512 (xcb-proto-1.14.tar.xz) = de66d568163b6da2be9d6c59984f3afa3acd119a7813786 SHA512 (depot_tools.git-master.tar.gz) = dc323888812b66cc92c53a24a8a58ccf9e2961be67aa21852bd091b8b49569071f06ae9104cb58950e6253ac3a29f0db0663e9f35ef2b1ea28696efb38b42708 SHA512 (NotoSansSymbols2-Regular.ttf) = 2644b42c3fdccfe12395f9b61553aced169a0f1dc09f5a0fd7898e9d0a372ee4422b6b1cdab3c86ecc91db437e9ae8a951e64e85edc3ac9e9fca428852dbb2ad SHA512 (NotoSansTibetan-Regular.ttf) = fb5a48fcaea80eebe7d692f6fcf00d59d47658a358d0ec8e046fc559873f88bd595b2da474d2826abd9e9305f3741c69058d867b1e6048f37fe7d71b5d3af36a -SHA512 (chromium-86.0.4240.75-clean.tar.xz) = 9832895a138758522c1ea926bdf05116b3494196b19852ef0ee85c6fb333afea0d19d9950b74aa93cc6731bafc119768ae610d7c69fd21da10de2b4599006963 +SHA512 (chromium-86.0.4240.111-clean.tar.xz) = 51f779e6f6549442e4392087c3aff48931e254b69ab2bbe9d25c3523de7a62dc9fadd99ba7dd22c614b2031ca93f35184bf14de7fdfb79abc0d5139078d695de