BASELINE: Update Chromium to 106.0.5249.126

Change-Id: Ib0bb21c437a7d1686e21c33f2d329f2ac425b7ab
Reviewed-on: https://codereview.qt-project.org/c/qt/qtwebengine-chromium/+/438936
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 65 insertions, 59 deletions

diff --git a/chromium/base/trace_event/trace_config.cc b/chromium/base/trace_event/trace_config.cc
index 7882ab23751..af5f945a844 100644
--- a/chromium/base/trace_event/trace_config.cc
+++ b/chromium/base/trace_event/trace_config.cc
@@ -158,19 +158,22 @@ void TraceConfig::ProcessFilterConfig::InitializeFromConfigDict(
   if (!value)
     return;
   for (auto& pid_value : value->GetListDeprecated()) {
-    if (pid_value.is_int())
-      included_process_ids_.insert(pid_value.GetInt());
+    if (pid_value.is_int()) {
+      included_process_ids_.insert(
+          static_cast<base::ProcessId>(pid_value.GetInt()));
+    }
   }
 }
 
-void TraceConfig::ProcessFilterConfig::ToDict(Value* dict) const {
+void TraceConfig::ProcessFilterConfig::ToDict(Value::Dict& dict) const {
   if (included_process_ids_.empty())
     return;
-  Value* list = dict->SetKey(kIncludedProcessesParam, Value(Value::Type::LIST));
+  base::Value::List list;
   std::set<base::ProcessId> ordered_set(included_process_ids_.begin(),
                                         included_process_ids_.end());
   for (auto process_id : ordered_set)
-    list->Append(static_cast<int>(process_id));
+    list.Append(static_cast<int>(process_id));
+  dict.Set(kIncludedProcessesParam, std::move(list));
 }
 
 bool TraceConfig::ProcessFilterConfig::IsEnabled(
@@ -217,13 +220,13 @@ void TraceConfig::EventFilterConfig::SetCategoryFilter(
   category_filter_ = category_filter;
 }
 
-void TraceConfig::EventFilterConfig::ToDict(Value* filter_dict) const {
-  filter_dict->SetStringKey(kFilterPredicateParam, predicate_name());
+void TraceConfig::EventFilterConfig::ToDict(Value::Dict& filter_dict) const {
+  filter_dict.Set(kFilterPredicateParam, predicate_name());
 
   category_filter_.ToDict(filter_dict);
 
   if (!args_.is_none())
-    filter_dict->SetKey(kFilterArgsParam, args_.Clone());
+    filter_dict.Set(kFilterArgsParam, args_.Clone());
 }
 
 bool TraceConfig::EventFilterConfig::GetArgAsSet(
@@ -393,9 +396,10 @@ void TraceConfig::InitializeFromConfigDict(const Value& dict) {
       record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
     }
   }
-  trace_buffer_size_in_events_ =
-      dict.FindIntKey(kTraceBufferSizeInEvents).value_or(0);
-  trace_buffer_size_in_kb_ = dict.FindIntKey(kTraceBufferSizeInKb).value_or(0);
+  trace_buffer_size_in_events_ = base::saturated_cast<size_t>(
+      dict.FindIntKey(kTraceBufferSizeInEvents).value_or(0));
+  trace_buffer_size_in_kb_ = base::saturated_cast<size_t>(
+      dict.FindIntKey(kTraceBufferSizeInKb).value_or(0));
 
   enable_systrace_ = dict.FindBoolKey(kEnableSystraceParam).value_or(false);
   enable_argument_filter_ =
@@ -557,7 +561,7 @@ void TraceConfig::SetMemoryDumpConfigFromConfigDict(
         heap_profiler_options->FindIntKey(kBreakdownThresholdBytes);
     if (min_size_bytes && *min_size_bytes >= 0) {
       memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
-          *min_size_bytes;
+          static_cast<uint32_t>(*min_size_bytes);
     } else {
       memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
           MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes;
@@ -600,87 +604,89 @@ void TraceConfig::SetEventFiltersFromConfigList(
 }
 
 Value TraceConfig::ToValue() const {
-  Value dict(Value::Type::DICTIONARY);
-  dict.SetStringKey(kRecordModeParam,
-                    TraceConfig::TraceRecordModeToStr(record_mode_));
-  dict.SetBoolKey(kEnableSystraceParam, enable_systrace_);
-  dict.SetBoolKey(kEnableArgumentFilterParam, enable_argument_filter_);
-  if (trace_buffer_size_in_events_ > 0)
-    dict.SetIntKey(kTraceBufferSizeInEvents, trace_buffer_size_in_events_);
-  if (trace_buffer_size_in_kb_ > 0)
-    dict.SetIntKey(kTraceBufferSizeInKb, trace_buffer_size_in_kb_);
-
-  dict.SetBoolKey(kEnableEventPackageNameFilterParam,
-                  enable_event_package_name_filter_);
-
-  category_filter_.ToDict(&dict);
-  process_filter_config_.ToDict(&dict);
+  Value::Dict dict;
+  dict.Set(kRecordModeParam, TraceConfig::TraceRecordModeToStr(record_mode_));
+  dict.Set(kEnableSystraceParam, enable_systrace_);
+  dict.Set(kEnableArgumentFilterParam, enable_argument_filter_);
+  if (trace_buffer_size_in_events_ > 0) {
+    dict.Set(kTraceBufferSizeInEvents,
+             base::checked_cast<int>(trace_buffer_size_in_events_));
+  }
+  if (trace_buffer_size_in_kb_ > 0) {
+    dict.Set(kTraceBufferSizeInKb,
+             base::checked_cast<int>(trace_buffer_size_in_kb_));
+  }
+
+  dict.Set(kEnableEventPackageNameFilterParam,
+           enable_event_package_name_filter_);
+
+  category_filter_.ToDict(dict);
+  process_filter_config_.ToDict(dict);
 
   if (!event_filters_.empty()) {
-    std::vector<Value> filter_list;
+    Value::List filter_list;
     for (const EventFilterConfig& filter : event_filters_) {
-      filter_list.emplace_back(Value::Type::DICTIONARY);
-      filter.ToDict(&filter_list.back());
+      Value::Dict filter_dict;
+      filter.ToDict(filter_dict);
+      filter_list.Append(std::move(filter_dict));
     }
-    dict.SetKey(kEventFiltersParam, Value(std::move(filter_list)));
+    dict.Set(kEventFiltersParam, std::move(filter_list));
   }
 
   if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
-    std::vector<Value> allowed_modes;
+    Value::List allowed_modes;
     for (auto dump_mode : memory_dump_config_.allowed_dump_modes)
-      allowed_modes.emplace_back(MemoryDumpLevelOfDetailToString(dump_mode));
+      allowed_modes.Append(MemoryDumpLevelOfDetailToString(dump_mode));
 
-    Value memory_dump_config(Value::Type::DICTIONARY);
-    memory_dump_config.SetKey(kAllowedDumpModesParam,
-                              Value(std::move(allowed_modes)));
+    Value::Dict memory_dump_config;
+    memory_dump_config.Set(kAllowedDumpModesParam, std::move(allowed_modes));
 
-    std::vector<Value> triggers_list;
+    Value::List triggers_list;
     for (const auto& config : memory_dump_config_.triggers) {
-      triggers_list.emplace_back(Value::Type::DICTIONARY);
-      Value& trigger_dict = triggers_list.back();
-
-      trigger_dict.SetStringKey(kTriggerTypeParam,
-                                MemoryDumpTypeToString(config.trigger_type));
-      trigger_dict.SetIntKey(
-          kMinTimeBetweenDumps,
-          static_cast<int>(config.min_time_between_dumps_ms));
-      trigger_dict.SetStringKey(
-          kTriggerModeParam,
-          MemoryDumpLevelOfDetailToString(config.level_of_detail));
+      Value::Dict trigger_dict;
+
+      trigger_dict.Set(kTriggerTypeParam,
+                       MemoryDumpTypeToString(config.trigger_type));
+      trigger_dict.Set(kMinTimeBetweenDumps,
+                       static_cast<int>(config.min_time_between_dumps_ms));
+      trigger_dict.Set(kTriggerModeParam,
+                       MemoryDumpLevelOfDetailToString(config.level_of_detail));
+      triggers_list.Append(std::move(trigger_dict));
     }
 
     // Empty triggers will still be specified explicitly since it means that
     // the periodic dumps are not enabled.
-    memory_dump_config.SetKey(kTriggersParam, Value(std::move(triggers_list)));
+    memory_dump_config.Set(kTriggersParam, std::move(triggers_list));
 
     if (memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes !=
         MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes) {
       Value options(Value::Type::DICTIONARY);
       options.SetIntKey(
           kBreakdownThresholdBytes,
-          memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes);
-      memory_dump_config.SetKey(kHeapProfilerOptions, std::move(options));
+          base::checked_cast<int>(memory_dump_config_.heap_profiler_options
+                                      .breakdown_threshold_bytes));
+      memory_dump_config.Set(kHeapProfilerOptions, std::move(options));
     }
-    dict.SetKey(kMemoryDumpConfigParam, std::move(memory_dump_config));
+    dict.Set(kMemoryDumpConfigParam, std::move(memory_dump_config));
   }
 
   if (!histogram_names_.empty()) {
-    std::vector<Value> histogram_names;
+    base::Value::List histogram_names;
     for (const std::string& histogram_name : histogram_names_)
-      histogram_names.emplace_back(histogram_name);
-    dict.SetKey(kHistogramNamesParam, Value(std::move(histogram_names)));
+      histogram_names.Append(histogram_name);
+    dict.Set(kHistogramNamesParam, std::move(histogram_names));
   }
 
   if (enable_systrace_) {
     if (!systrace_events_.empty()) {
-      std::vector<Value> systrace_events;
+      base::Value::List systrace_events;
       for (const std::string& systrace_event : systrace_events_)
-        systrace_events.emplace_back(systrace_event);
-      dict.SetKey(kSystraceEventsParam, Value(std::move(systrace_events)));
+        systrace_events.Append(systrace_event);
+      dict.Set(kSystraceEventsParam, std::move(systrace_events));
     }
   }
 
-  return dict;
+  return Value(std::move(dict));
 }
 
 void TraceConfig::EnableSystraceEvent(const std::string& systrace_event) {