BASELINE: Update Chromium to 79.0.3945.139

Change-Id: I336b7182fab9bca80b709682489c07db112eaca5
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

14 files changed, 225 insertions, 48 deletions

diff --git a/chromium/base/trace_event/OWNERS b/chromium/base/trace_event/OWNERS
index aa3ab84aa9f..8d95238ff95 100644
--- a/chromium/base/trace_event/OWNERS
+++ b/chromium/base/trace_event/OWNERS
@@ -1,4 +1,3 @@
-chiniforooshan@chromium.org
 eseckler@chromium.org
 oysteine@chromium.org
 primiano@chromium.org
diff --git a/chromium/base/trace_event/blame_context.cc b/chromium/base/trace_event/blame_context.cc
index 3c5f32ab464..e7599efa83f 100644
--- a/chromium/base/trace_event/blame_context.cc
+++ b/chromium/base/trace_event/blame_context.cc
@@ -40,6 +40,8 @@ BlameContext::~BlameContext() {
 
 void BlameContext::Enter() {
   DCHECK(WasInitialized());
+  if (LIKELY(!*category_group_enabled_))
+    return;
   TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_ENTER_CONTEXT,
                                   category_group_enabled_, name_, scope_, id_,
                                   nullptr, TRACE_EVENT_FLAG_HAS_ID);
@@ -47,6 +49,8 @@ void BlameContext::Enter() {
 
 void BlameContext::Leave() {
   DCHECK(WasInitialized());
+  if (LIKELY(!*category_group_enabled_))
+    return;
   TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_LEAVE_CONTEXT,
                                   category_group_enabled_, name_, scope_, id_,
                                   nullptr, TRACE_EVENT_FLAG_HAS_ID);
@@ -55,7 +59,7 @@ void BlameContext::Leave() {
 void BlameContext::TakeSnapshot() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(WasInitialized());
-  if (!*category_group_enabled_)
+  if (LIKELY(!*category_group_enabled_))
     return;
   std::unique_ptr<trace_event::TracedValue> snapshot(
       new trace_event::TracedValue);
diff --git a/chromium/base/trace_event/builtin_categories.h b/chromium/base/trace_event/builtin_categories.h
index 6717a2bd93b..1ac3513eb4f 100644
--- a/chromium/base/trace_event/builtin_categories.h
+++ b/chromium/base/trace_event/builtin_categories.h
@@ -15,6 +15,9 @@
 // your code and you get a static assert, this is the right place to register
 // the name. If the name is going to be used only for testing, please add it to
 // |kIgnoredCategoriesForTesting| instead.
+//
+// Prefer to use '_' to separate word of category name, like content_capture.
+//
 // Parameter |X| must be a *macro* that takes a single |name| string argument,
 // denoting a category name.
 #define INTERNAL_TRACE_LIST_BUILTIN_CATEGORIES(X)                        \
@@ -52,6 +55,7 @@
   X("cma")                                                               \
   X("compositor")                                                        \
   X("content")                                                           \
+  X("content_capture")                                                   \
   X("devtools")                                                          \
   X("devtools.timeline")                                                 \
   X("devtools.timeline.async")                                           \
@@ -139,6 +143,7 @@
   X("vk")                                                                \
   X("wayland")                                                           \
   X("webaudio")                                                          \
+  X("weblayer")                                                          \
   X("WebCore")                                                           \
   X("webrtc")                                                            \
   X("xr")                                                                \
@@ -177,6 +182,7 @@
   X(TRACE_DISABLED_BY_DEFAULT("gpu.device"))                             \
   X(TRACE_DISABLED_BY_DEFAULT("gpu.service"))                            \
   X(TRACE_DISABLED_BY_DEFAULT("ipc.flow"))                               \
+  X(TRACE_DISABLED_BY_DEFAULT("java-heap-profiler"))                     \
   X(TRACE_DISABLED_BY_DEFAULT("layer-element"))                          \
   X(TRACE_DISABLED_BY_DEFAULT("lifecycles"))                             \
   X(TRACE_DISABLED_BY_DEFAULT("loading"))                                \
diff --git a/chromium/base/trace_event/malloc_dump_provider.cc b/chromium/base/trace_event/malloc_dump_provider.cc
index e89597c1d6b..7e42cfc20bb 100644
--- a/chromium/base/trace_event/malloc_dump_provider.cc
+++ b/chromium/base/trace_event/malloc_dump_provider.cc
@@ -134,7 +134,10 @@ bool MallocDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
 // TODO(fuchsia): Port, see https://crbug.com/706592.
 #else
   struct mallinfo info = mallinfo();
-  DCHECK_GE(info.arena + info.hblkhd, info.uordblks);
+#if !defined(ADDRESS_SANITIZER) && !defined(THREAD_SANITIZER)
+  // Sanitizers override mallinfo.
+  DCHECK_GT(static_cast<int>(info.uordblks), 0);
+#endif
 
   // In case of Android's jemalloc |arena| is 0 and the outer pages size is
   // reported by |hblkhd|. In case of dlmalloc the total is given by
diff --git a/chromium/base/trace_event/memory_dump_manager.cc b/chromium/base/trace_event/memory_dump_manager.cc
index 8b1bd7a0a58..d79d405ac9f 100644
--- a/chromium/base/trace_event/memory_dump_manager.cc
+++ b/chromium/base/trace_event/memory_dump_manager.cc
@@ -529,7 +529,8 @@ MemoryDumpManager::ProcessMemoryDumpAsyncState::ProcessMemoryDumpAsyncState(
       dump_thread_task_runner(std::move(dump_thread_task_runner)) {
   pending_dump_providers.reserve(dump_providers.size());
   pending_dump_providers.assign(dump_providers.rbegin(), dump_providers.rend());
-  MemoryDumpArgs args = {req_args.level_of_detail, req_args.dump_guid};
+  MemoryDumpArgs args = {req_args.level_of_detail, req_args.determinism,
+                         req_args.dump_guid};
   process_memory_dump = std::make_unique<ProcessMemoryDump>(args);
 }
 
diff --git a/chromium/base/trace_event/memory_dump_manager_unittest.cc b/chromium/base/trace_event/memory_dump_manager_unittest.cc
index b33b677beb9..c7b413d46a5 100644
--- a/chromium/base/trace_event/memory_dump_manager_unittest.cc
+++ b/chromium/base/trace_event/memory_dump_manager_unittest.cc
@@ -54,6 +54,14 @@ MATCHER(IsLightDump, "") {
   return arg.level_of_detail == MemoryDumpLevelOfDetail::LIGHT;
 }
 
+MATCHER(IsDeterministicDump, "") {
+  return arg.determinism == MemoryDumpDeterminism::FORCE_GC;
+}
+
+MATCHER(IsNotDeterministicDump, "") {
+  return arg.determinism == MemoryDumpDeterminism::NONE;
+}
+
 namespace {
 
 const char* kMDPName = "TestDumpProvider";
@@ -193,12 +201,14 @@ class MemoryDumpManagerTest : public testing::Test {
   // memory dump is complete. Returns:
   // - return value: the |success| from the CreateProcessDump() callback.
   bool RequestProcessDumpAndWait(MemoryDumpType dump_type,
-                                 MemoryDumpLevelOfDetail level_of_detail) {
+                                 MemoryDumpLevelOfDetail level_of_detail,
+                                 MemoryDumpDeterminism determinism) {
     RunLoop run_loop;
     bool success = false;
     static uint64_t test_guid = 1;
     test_guid++;
-    MemoryDumpRequestArgs request_args{test_guid, dump_type, level_of_detail};
+    MemoryDumpRequestArgs request_args{test_guid, dump_type, level_of_detail,
+                                       determinism};
 
     // The signature of the callback delivered by MemoryDumpManager is:
     // void ProcessMemoryDumpCallback(
@@ -276,7 +286,8 @@ TEST_F(MemoryDumpManagerTest, SingleDumper) {
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3);
   for (int i = 0; i < 3; ++i) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
   }
   DisableTracing();
 
@@ -288,7 +299,8 @@ TEST_F(MemoryDumpManagerTest, SingleDumper) {
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
   for (int i = 0; i < 3; ++i) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
   }
   DisableTracing();
 }
@@ -302,7 +314,8 @@ TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
   EnableForTracing();
   EXPECT_CALL(mdp, OnMemoryDump(IsDetailedDump(), _));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   DisableTracing();
   mdm_->UnregisterDumpProvider(&mdp);
 
@@ -312,7 +325,34 @@ TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
   EnableForTracing();
   EXPECT_CALL(mdp, OnMemoryDump(IsLightDump(), _));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::LIGHT));
+                                        MemoryDumpLevelOfDetail::LIGHT,
+                                        MemoryDumpDeterminism::NONE));
+  DisableTracing();
+  mdm_->UnregisterDumpProvider(&mdp);
+}
+
+// Checks that requesting deterministic dumps actually propagates
+// the deterministic option properly to OnMemoryDump() call on dump providers.
+TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgsDeterministic) {
+  MockMemoryDumpProvider mdp;
+
+  RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
+  EnableForTracing();
+  EXPECT_CALL(mdp, OnMemoryDump(IsDeterministicDump(), _));
+  EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::FORCE_GC));
+  DisableTracing();
+  mdm_->UnregisterDumpProvider(&mdp);
+
+  // Check that requesting dumps with deterministic option set to false
+  // actually propagates to OnMemoryDump() call on dump providers.
+  RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
+  EnableForTracing();
+  EXPECT_CALL(mdp, OnMemoryDump(IsNotDeterministicDump(), _));
+  EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
+                                        MemoryDumpLevelOfDetail::LIGHT,
+                                        MemoryDumpDeterminism::NONE));
   DisableTracing();
   mdm_->UnregisterDumpProvider(&mdp);
 }
@@ -328,7 +368,8 @@ TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
   EXPECT_CALL(mdp1, OnMemoryDump(_, _));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0);
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   DisableTracing();
 
   // Invert: enable mdp2 and disable mdp1.
@@ -338,7 +379,8 @@ TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
   EXPECT_CALL(mdp2, OnMemoryDump(_, _));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   DisableTracing();
 
   // Enable both mdp1 and mdp2.
@@ -347,7 +389,8 @@ TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
   EXPECT_CALL(mdp1, OnMemoryDump(_, _));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   DisableTracing();
 }
 
@@ -368,7 +411,8 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
     EXPECT_CALL(mdp, OnMemoryDump(_, _));
     EnableForTracing();
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
     DisableTracing();
   }
 
@@ -378,7 +422,8 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
     EnableForTracing();
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
     DisableTracing();
   }
 
@@ -389,7 +434,8 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
     EnableForTracing();
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
     DisableTracing();
   }
 
@@ -401,7 +447,8 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
     EXPECT_CALL(mdp, OnMemoryDump(_, _));
     EnableForTracing();
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
     DisableTracing();
   }
 }
@@ -439,7 +486,8 @@ TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) {
 
   while (!threads.empty()) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
 
     // Unregister a MDP and destroy one thread at each iteration to check the
     // live unregistration logic. The unregistration needs to happen on the same
@@ -485,13 +533,15 @@ TEST_F(MemoryDumpManagerTest, PostTaskForSequencedTaskRunner) {
 
   task_runner1->set_enabled(false);
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   EXPECT_EQ(1u, task_runner1->no_of_post_tasks());
   EXPECT_EQ(1u, task_runner2->no_of_post_tasks());
 
   task_runner1->set_enabled(true);
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   EXPECT_EQ(2u, task_runner1->no_of_post_tasks());
   EXPECT_EQ(2u, task_runner2->no_of_post_tasks());
   DisableTracing();
@@ -522,7 +572,8 @@ TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) {
   const int kNumDumps = 2 * GetMaxConsecutiveFailuresCount();
   for (int i = 0; i < kNumDumps; i++) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
   }
 
   DisableTracing();
@@ -553,7 +604,8 @@ TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) {
 
   for (int i = 0; i < 4; i++) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
   }
 
   DisableTracing();
@@ -584,7 +636,8 @@ TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) {
 
   for (int i = 0; i < 4; i++) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
   }
 
   DisableTracing();
@@ -632,7 +685,8 @@ TEST_F(MemoryDumpManagerTest, UnregisterDumperFromThreadWhileDumping) {
 
   EnableForTracing();
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   ASSERT_EQ(1, on_memory_dump_call_count);
 
   DisableTracing();
@@ -679,7 +733,8 @@ TEST_F(MemoryDumpManagerTest, TearDownThreadWhileDumping) {
 
   EnableForTracing();
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   ASSERT_EQ(1, on_memory_dump_call_count);
 
   DisableTracing();
@@ -692,7 +747,8 @@ TEST_F(MemoryDumpManagerTest, TriggerDumpWithoutTracing) {
   RegisterDumpProvider(&mdp, nullptr);
   EXPECT_CALL(mdp, OnMemoryDump(_, _));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
 }
 
 TEST_F(MemoryDumpManagerTest, BackgroundWhitelisting) {
@@ -707,7 +763,8 @@ TEST_F(MemoryDumpManagerTest, BackgroundWhitelisting) {
 
   EXPECT_CALL(backgroundMdp, OnMemoryDump(_, _)).Times(1);
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
-                                        MemoryDumpLevelOfDetail::BACKGROUND));
+                                        MemoryDumpLevelOfDetail::BACKGROUND,
+                                        MemoryDumpDeterminism::NONE));
   DisableTracing();
 }
 
@@ -769,7 +826,8 @@ TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoonDuringDump) {
   EnableForTracing();
   for (int i = 0; i < 2; ++i) {
     EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                          MemoryDumpLevelOfDetail::DETAILED));
+                                          MemoryDumpLevelOfDetail::DETAILED,
+                                          MemoryDumpDeterminism::NONE));
   }
   DisableTracing();
 }
@@ -822,11 +880,14 @@ TEST_F(MemoryDumpManagerTest, NoStackOverflowWithTooManyMDPs) {
   stopped_thread->Stop();
 
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::DETAILED));
+                                        MemoryDumpLevelOfDetail::DETAILED,
+                                        MemoryDumpDeterminism::NONE));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        MemoryDumpLevelOfDetail::BACKGROUND));
+                                        MemoryDumpLevelOfDetail::BACKGROUND,
+                                        MemoryDumpDeterminism::NONE));
   EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
-                                        MemoryDumpLevelOfDetail::BACKGROUND));
+                                        MemoryDumpLevelOfDetail::BACKGROUND,
+                                        MemoryDumpDeterminism::NONE));
 }
 
 }  // namespace trace_event
diff --git a/chromium/base/trace_event/memory_dump_request_args.h b/chromium/base/trace_event/memory_dump_request_args.h
index c50a1cb2cfc..d62a0dc84c8 100644
--- a/chromium/base/trace_event/memory_dump_request_args.h
+++ b/chromium/base/trace_event/memory_dump_request_args.h
@@ -58,6 +58,12 @@ enum class MemoryDumpLevelOfDetail : uint32_t {
   LAST = DETAILED
 };
 
+// Tells the MemoryDumpProvider(s) if they should try to make the result
+// more deterministic by forcing garbage collection.
+// Keep this consistent with memory_instrumentation.mojo and
+// memory_instrumentation_struct_traits.{h,cc}
+enum class MemoryDumpDeterminism : uint32_t { NONE, FORCE_GC };
+
 // Keep this consistent with memory_instrumentation.mojo and
 // memory_instrumentation_struct_traits.{h,cc}
 struct BASE_EXPORT MemoryDumpRequestArgs {
@@ -68,6 +74,7 @@ struct BASE_EXPORT MemoryDumpRequestArgs {
 
   MemoryDumpType dump_type;
   MemoryDumpLevelOfDetail level_of_detail;
+  MemoryDumpDeterminism determinism;
 };
 
 // Args for ProcessMemoryDump and passed to OnMemoryDump calls for memory dump
@@ -75,6 +82,8 @@ struct BASE_EXPORT MemoryDumpRequestArgs {
 struct MemoryDumpArgs {
   // Specifies how detailed the dumps should be.
   MemoryDumpLevelOfDetail level_of_detail;
+  // Specifies whether the dumps should be more deterministic.
+  MemoryDumpDeterminism determinism;
 
   // Globally unique identifier. In multi-process dumps, all processes issue a
   // local dump with the same guid. This allows the trace importers to
diff --git a/chromium/base/trace_event/memory_infra_background_whitelist.cc b/chromium/base/trace_event/memory_infra_background_whitelist.cc
index 3874f4521ea..4c88b5ca4a5 100644
--- a/chromium/base/trace_event/memory_infra_background_whitelist.cc
+++ b/chromium/base/trace_event/memory_infra_background_whitelist.cc
@@ -67,8 +67,8 @@ const char* const kDumpProviderWhitelist[] = {
 // A list of string names that are allowed for the memory allocator dumps in
 // background mode.
 const char* const kAllocatorDumpNameWhitelist[] = {
-    "blink_gc",
-    "blink_gc/allocated_objects",
+    "blink_gc/main/heap",
+    "blink_gc/workers/heap/worker_0x?",
     "blink_objects/AdSubframe",
     "blink_objects/AudioHandler",
     "blink_objects/ContextLifecycleStateObserver",
@@ -344,6 +344,8 @@ const char* const kAllocatorDumpNameWhitelist[] = {
     "sync/0x?/model_type/MANAGED_USER_WHITELIST",
     "sync/0x?/model_type/MOUNTAIN_SHARE",
     "sync/0x?/model_type/NIGORI",
+    "sync/0x?/model_type/OS_PREFERENCE",
+    "sync/0x?/model_type/OS_PRIORITY_PREFERENCE",
     "sync/0x?/model_type/PASSWORD",
     "sync/0x?/model_type/PREFERENCE",
     "sync/0x?/model_type/PRINTER",
diff --git a/chromium/base/trace_event/trace_config.cc b/chromium/base/trace_event/trace_config.cc
index 061100c23ad..5b4493f1bd6 100644
--- a/chromium/base/trace_event/trace_config.cc
+++ b/chromium/base/trace_event/trace_config.cc
@@ -28,6 +28,8 @@ const char kRecordContinuously[] = "record-continuously";
 const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
 const char kTraceToConsole[] = "trace-to-console";
 const char kEnableSystrace[] = "enable-systrace";
+constexpr int kEnableSystraceLength = sizeof(kEnableSystrace) - 1;
+
 const char kEnableArgumentFilter[] = "enable-argument-filter";
 
 // String parameters that can be used to parse the trace config string.
@@ -35,6 +37,7 @@ const char kRecordModeParam[] = "record_mode";
 const char kTraceBufferSizeInEvents[] = "trace_buffer_size_in_events";
 const char kTraceBufferSizeInKb[] = "trace_buffer_size_in_kb";
 const char kEnableSystraceParam[] = "enable_systrace";
+const char kSystraceEventsParam[] = "enable_systrace_events";
 const char kEnableArgumentFilterParam[] = "enable_argument_filter";
 
 // String parameters that is used to parse memory dump config in trace config
@@ -163,7 +166,7 @@ void TraceConfig::ProcessFilterConfig::ToDict(Value* dict) const {
   std::set<base::ProcessId> ordered_set(included_process_ids_.begin(),
                                         included_process_ids_.end());
   for (auto process_id : ordered_set)
-    list->GetList().emplace_back(static_cast<int>(process_id));
+    list->Append(static_cast<int>(process_id));
 }
 
 bool TraceConfig::ProcessFilterConfig::IsEnabled(
@@ -298,6 +301,7 @@ TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
   memory_dump_config_ = rhs.memory_dump_config_;
   event_filters_ = rhs.event_filters_;
   histogram_names_ = rhs.histogram_names_;
+  systrace_events_ = rhs.systrace_events_;
   return *this;
 }
 
@@ -355,6 +359,7 @@ void TraceConfig::Clear() {
   process_filter_config_.Clear();
   event_filters_.clear();
   histogram_names_.clear();
+  systrace_events_.clear();
 }
 
 void TraceConfig::InitializeDefault() {
@@ -406,6 +411,15 @@ void TraceConfig::InitializeFromConfigDict(const Value& dict) {
     else
       SetDefaultMemoryDumpConfig();
   }
+
+  systrace_events_.clear();
+  if (enable_systrace_) {
+    const Value* systrace_events = dict.FindListKey(kSystraceEventsParam);
+    if (systrace_events) {
+      for (const Value& value : systrace_events->GetList())
+        systrace_events_.insert(value.GetString());
+    }
+  }
 }
 
 void TraceConfig::InitializeFromConfigString(StringPiece config_string) {
@@ -425,6 +439,7 @@ void TraceConfig::InitializeFromStrings(StringPiece category_filter_string,
   trace_buffer_size_in_events_ = 0;
   trace_buffer_size_in_kb_ = 0;
   enable_systrace_ = false;
+  systrace_events_.clear();
   enable_argument_filter_ = false;
   if (!trace_options_string.empty()) {
     std::vector<std::string> split =
@@ -438,8 +453,27 @@ void TraceConfig::InitializeFromStrings(StringPiece category_filter_string,
         record_mode_ = ECHO_TO_CONSOLE;
       } else if (token == kRecordAsMuchAsPossible) {
         record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
-      } else if (token == kEnableSystrace) {
+      } else if (token.find(kEnableSystrace) == 0) {
+        // Find optional events list.
+        const size_t length = token.length();
+        if (length == kEnableSystraceLength) {
+          // Use all predefined categories.
+          enable_systrace_ = true;
+          continue;
+        }
+        const auto system_events_not_trimmed =
+            token.substr(kEnableSystraceLength);
+        const auto system_events =
+            TrimString(system_events_not_trimmed, kWhitespaceASCII, TRIM_ALL);
+        if (system_events[0] != '=') {
+          LOG(ERROR) << "Failed to parse " << token;
+          continue;
+        }
         enable_systrace_ = true;
+        const std::vector<std::string> split_systrace_events = SplitString(
+            system_events.substr(1), " ", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+        for (const std::string& systrace_event : split_systrace_events)
+          systrace_events_.insert(systrace_event);
       } else if (token == kEnableArgumentFilter) {
         enable_argument_filter_ = true;
       }
@@ -622,9 +656,22 @@ Value TraceConfig::ToValue() const {
     dict.SetKey(kHistogramNamesParam, Value(std::move(histogram_names)));
   }
 
+  if (enable_systrace_) {
+    if (!systrace_events_.empty()) {
+      std::vector<Value> systrace_events;
+      for (const std::string& systrace_event : systrace_events_)
+        systrace_events.emplace_back(systrace_event);
+      dict.SetKey(kSystraceEventsParam, Value(std::move(systrace_events)));
+    }
+  }
+
   return dict;
 }
 
+void TraceConfig::EnableSystraceEvent(const std::string& systrace_event) {
+  systrace_events_.insert(systrace_event);
+}
+
 void TraceConfig::EnableHistogram(const std::string& histogram_name) {
   histogram_names_.insert(histogram_name);
 }
@@ -647,10 +694,24 @@ std::string TraceConfig::ToTraceOptionsString() const {
     default:
       NOTREACHED();
   }
-  if (enable_systrace_)
-    ret = ret + "," + kEnableSystrace;
-  if (enable_argument_filter_)
-    ret = ret + "," + kEnableArgumentFilter;
+  if (enable_systrace_) {
+    ret += ",";
+    ret += kEnableSystrace;
+    bool first_param = true;
+    for (const std::string& systrace_event : systrace_events_) {
+      if (first_param) {
+        ret += "=";
+        first_param = false;
+      } else {
+        ret += " ";
+      }
+      ret = ret + systrace_event;
+    }
+  }
+  if (enable_argument_filter_) {
+    ret += ",";
+    ret += kEnableArgumentFilter;
+  }
   return ret;
 }
 
diff --git a/chromium/base/trace_event/trace_config.h b/chromium/base/trace_event/trace_config.h
index 9798c7f6ae9..3e3d0078a7f 100644
--- a/chromium/base/trace_event/trace_config.h
+++ b/chromium/base/trace_event/trace_config.h
@@ -242,6 +242,7 @@ class BASE_EXPORT TraceConfig {
   }
   void SetTraceBufferSizeInKb(size_t size) { trace_buffer_size_in_kb_ = size; }
   void EnableSystrace() { enable_systrace_ = true; }
+  void EnableSystraceEvent(const std::string& systrace_event);
   void EnableArgumentFilter() { enable_argument_filter_ = true; }
   void EnableHistogram(const std::string& histogram_name);
 
@@ -255,6 +256,11 @@ class BASE_EXPORT TraceConfig {
   // Write the string representation of the CategoryFilter part.
   std::string ToCategoryFilterString() const;
 
+  // Write the string representation of the trace options part (record mode,
+  // systrace, argument filtering). Does not include category filters, event
+  // filters, or memory dump configs.
+  std::string ToTraceOptionsString() const;
+
   // Returns true if at least one category in the list is enabled by this
   // trace config. This is used to determine if the category filters are
   // enabled in the TRACE_* macros.
@@ -286,6 +292,10 @@ class BASE_EXPORT TraceConfig {
     event_filters_ = filter_configs;
   }
 
+  const std::unordered_set<std::string>& systrace_events() const {
+    return systrace_events_;
+  }
+
   const std::unordered_set<std::string>& histogram_names() const {
     return histogram_names_;
   }
@@ -294,6 +304,7 @@ class BASE_EXPORT TraceConfig {
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidLegacyFormat);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest,
                            TraceConfigFromInvalidLegacyStrings);
+  FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, SystraceEventsSerialization);
 
   // The default trace config, used when none is provided.
   // Allows all non-disabled-by-default categories through, except if they end
@@ -317,8 +328,6 @@ class BASE_EXPORT TraceConfig {
   void SetEventFiltersFromConfigList(const Value& event_filters);
   Value ToValue() const;
 
-  std::string ToTraceOptionsString() const;
-
   TraceRecordMode record_mode_;
   size_t trace_buffer_size_in_events_ = 0;  // 0 specifies default size
   size_t trace_buffer_size_in_kb_ = 0;      // 0 specifies default size
@@ -332,6 +341,7 @@ class BASE_EXPORT TraceConfig {
 
   EventFilters event_filters_;
   std::unordered_set<std::string> histogram_names_;
+  std::unordered_set<std::string> systrace_events_;
 };
 
 }  // namespace trace_event
diff --git a/chromium/base/trace_event/trace_config_unittest.cc b/chromium/base/trace_event/trace_config_unittest.cc
index c7e98a4ce64..16cd67ecd9e 100644
--- a/chromium/base/trace_event/trace_config_unittest.cc
+++ b/chromium/base/trace_event/trace_config_unittest.cc
@@ -674,5 +674,25 @@ TEST(TraceConfigTest, LegacyStringToMemoryDumpConfig) {
       tc.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
 }
 
+TEST(TraceConfigTest, SystraceEventsSerialization) {
+  TraceConfig tc(MemoryDumpManager::kTraceCategory, "");
+  tc.EnableSystrace();
+  EXPECT_EQ(0U, tc.systrace_events().size());
+  tc.EnableSystraceEvent("power");            // As a events category
+  tc.EnableSystraceEvent("timer:tick_stop");  // As an event
+  EXPECT_EQ(2U, tc.systrace_events().size());
+
+  const TraceConfig tc1(MemoryDumpManager::kTraceCategory,
+                        tc.ToTraceOptionsString());
+  EXPECT_EQ(2U, tc1.systrace_events().size());
+  EXPECT_TRUE(tc1.systrace_events().count("power"));
+  EXPECT_TRUE(tc1.systrace_events().count("timer:tick_stop"));
+
+  const TraceConfig tc2(tc.ToString());
+  EXPECT_EQ(2U, tc2.systrace_events().size());
+  EXPECT_TRUE(tc2.systrace_events().count("power"));
+  EXPECT_TRUE(tc2.systrace_events().count("timer:tick_stop"));
+}
+
 }  // namespace trace_event
 }  // namespace base
diff --git a/chromium/base/trace_event/trace_log.cc b/chromium/base/trace_event/trace_log.cc
index 39c19c8e46b..1e0cd1413c4 100644
--- a/chromium/base/trace_event/trace_log.cc
+++ b/chromium/base/trace_event/trace_log.cc
@@ -378,7 +378,7 @@ TraceLog::TraceLog()
       num_traces_recorded_(0),
       process_sort_index_(0),
       process_id_hash_(0),
-      process_id_(0),
+      process_id_(base::kNullProcessId),
       trace_options_(kInternalRecordUntilFull),
       trace_config_(TraceConfig()),
       thread_shared_chunk_index_(0),
diff --git a/chromium/base/trace_event/trace_log.h b/chromium/base/trace_event/trace_log.h
index 63be5aa4649..e0c850ca41e 100644
--- a/chromium/base/trace_event/trace_log.h
+++ b/chromium/base/trace_event/trace_log.h
@@ -301,6 +301,7 @@ class BASE_EXPORT TraceLog : public MemoryDumpProvider {
                         TraceEventHandle handle);
 
   int process_id() const { return process_id_; }
+  const std::string& process_name() const { return process_name_; }
 
   uint64_t MangleEventId(uint64_t id);
 
diff --git a/chromium/base/trace_event/traced_value.cc b/chromium/base/trace_event/traced_value.cc
index b1ea5aabeac..5b6467a4a15 100644
--- a/chromium/base/trace_event/traced_value.cc
+++ b/chromium/base/trace_event/traced_value.cc
@@ -341,7 +341,7 @@ class PickleWriter final : public TracedValue::Writer {
             stack.push_back(cur_dict);
             cur_dict = cur_dict->SetKey(ReadKeyName(it), std::move(new_dict));
           } else {
-            cur_list->GetList().push_back(std::move(new_dict));
+            cur_list->Append(std::move(new_dict));
             // |new_dict| is invalidated at this point, so |cur_dict| needs to
             // be reset.
             cur_dict = &cur_list->GetList().back();
@@ -369,7 +369,7 @@ class PickleWriter final : public TracedValue::Writer {
             cur_list = cur_dict->SetKey(ReadKeyName(it), std::move(new_list));
             cur_dict = nullptr;
           } else {
-            cur_list->GetList().push_back(std::move(new_list));
+            cur_list->Append(std::move(new_list));
             stack.push_back(cur_list);
             // |cur_list| is invalidated at this point by the Append, so it
             // needs to be reset.
@@ -383,7 +383,7 @@ class PickleWriter final : public TracedValue::Writer {
           if (cur_dict) {
             cur_dict->SetBoolKey(ReadKeyName(it), value);
           } else {
-            cur_list->GetList().emplace_back(value);
+            cur_list->Append(value);
           }
         } break;
 
@@ -393,7 +393,7 @@ class PickleWriter final : public TracedValue::Writer {
           if (cur_dict) {
             cur_dict->SetIntKey(ReadKeyName(it), value);
           } else {
-            cur_list->GetList().emplace_back(value);
+            cur_list->Append(value);
           }
         } break;
 
@@ -403,7 +403,7 @@ class PickleWriter final : public TracedValue::Writer {
           if (cur_dict) {
             cur_dict->SetDoubleKey(ReadKeyName(it), value);
           } else {
-            cur_list->GetList().emplace_back(value);
+            cur_list->Append(value);
           }
         } break;
 
@@ -413,7 +413,7 @@ class PickleWriter final : public TracedValue::Writer {
           if (cur_dict) {
             cur_dict->SetStringKey(ReadKeyName(it), std::move(value));
           } else {
-            cur_list->GetList().emplace_back(std::move(value));
+            cur_list->Append(std::move(value));
           }
         } break;