BASELINE: Update Chromium to 78.0.3904.130

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

1 files changed, 74 insertions, 51 deletions

diff --git a/chromium/base/task/thread_pool/task_source.cc b/chromium/base/task/thread_pool/task_source.cc
index 6d39aebe7cb..271988c2400 100644
--- a/chromium/base/task/thread_pool/task_source.cc
+++ b/chromium/base/task/thread_pool/task_source.cc
@@ -15,30 +15,6 @@
 namespace base {
 namespace internal {
 
-TaskSource::RunIntent::RunIntent(RunIntent&& other) noexcept
-    : task_source_(other.task_source_),
-      run_step_(other.run_step_),
-      is_saturated_(other.is_saturated_) {
-  other.task_source_ = nullptr;
-}
-
-TaskSource::RunIntent::~RunIntent() {
-  DCHECK_EQ(task_source_, nullptr);
-}
-
-TaskSource::RunIntent& TaskSource::RunIntent::operator=(RunIntent&& other) {
-  DCHECK_EQ(task_source_, nullptr);
-  task_source_ = other.task_source_;
-  other.task_source_ = nullptr;
-  run_step_ = other.run_step_;
-  is_saturated_ = other.is_saturated_;
-  return *this;
-}
-
-TaskSource::RunIntent::RunIntent(const TaskSource* task_source,
-                                 Saturated is_saturated)
-    : task_source_(task_source), is_saturated_(is_saturated) {}
-
 TaskSource::Transaction::Transaction(TaskSource* task_source)
     : task_source_(task_source) {
   task_source->lock_.Acquire();
@@ -56,38 +32,16 @@ TaskSource::Transaction::~Transaction() {
   }
 }
 
-Optional<Task> TaskSource::Transaction::TakeTask(RunIntent* intent) {
-  DCHECK_EQ(intent->task_source_, task_source());
-  DCHECK_EQ(intent->run_step_, RunIntent::State::kInitial);
-  intent->run_step_ = RunIntent::State::kTaskAcquired;
-  return task_source_->TakeTask();
-}
-
-bool TaskSource::Transaction::DidProcessTask(RunIntent intent,
-                                             RunResult run_result) {
-  DCHECK_EQ(intent.task_source_, task_source());
-  DCHECK_EQ(intent.run_step_, RunIntent::State::kTaskAcquired);
-  intent.run_step_ = RunIntent::State::kCompleted;
-  intent.Release();
-  return task_source_->DidProcessTask(run_result);
-}
-
 SequenceSortKey TaskSource::Transaction::GetSortKey() const {
   return task_source_->GetSortKey();
 }
 
-void TaskSource::Transaction::Clear() {
-  task_source_->Clear();
-}
-
 void TaskSource::Transaction::UpdatePriority(TaskPriority priority) {
   if (FeatureList::IsEnabled(kAllTasksUserBlocking))
     return;
   task_source_->traits_.UpdatePriority(priority);
-}
-
-TaskSource::RunIntent TaskSource::MakeRunIntent(Saturated is_saturated) const {
-  return RunIntent(this, is_saturated);
+  task_source_->priority_racy_.store(task_source_->traits_.priority(),
+                                     std::memory_order_relaxed);
 }
 
 void TaskSource::SetHeapHandle(const HeapHandle& handle) {
@@ -102,6 +56,7 @@ TaskSource::TaskSource(const TaskTraits& traits,
                        TaskRunner* task_runner,
                        TaskSourceExecutionMode execution_mode)
     : traits_(traits),
+      priority_racy_(traits.priority()),
       task_runner_(task_runner),
       execution_mode_(execution_mode) {
   DCHECK(task_runner_ ||
@@ -121,7 +76,14 @@ RegisteredTaskSource::RegisteredTaskSource(std::nullptr_t)
     : RegisteredTaskSource() {}
 
 RegisteredTaskSource::RegisteredTaskSource(
-    RegisteredTaskSource&& other) noexcept = default;
+    RegisteredTaskSource&& other) noexcept
+    :
+#if DCHECK_IS_ON()
+      run_step_{std::exchange(other.run_step_, State::kInitial)},
+#endif  // DCHECK_IS_ON()
+      task_source_{std::move(other.task_source_)},
+      task_tracker_{std::exchange(other.task_tracker_, nullptr)} {
+}
 
 RegisteredTaskSource::~RegisteredTaskSource() {
   Unregister();
@@ -135,6 +97,9 @@ RegisteredTaskSource RegisteredTaskSource::CreateForTesting(
 }
 
 scoped_refptr<TaskSource> RegisteredTaskSource::Unregister() {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(run_step_, State::kInitial);
+#endif  // DCHECK_IS_ON()
   if (task_source_ && task_tracker_)
     return task_tracker_->UnregisterTaskSource(std::move(task_source_));
   return std::move(task_source_);
@@ -143,16 +108,74 @@ scoped_refptr<TaskSource> RegisteredTaskSource::Unregister() {
 RegisteredTaskSource& RegisteredTaskSource::operator=(
     RegisteredTaskSource&& other) {
   Unregister();
+#if DCHECK_IS_ON()
+  run_step_ = std::exchange(other.run_step_, State::kInitial);
+#endif  // DCHECK_IS_ON()
   task_source_ = std::move(other.task_source_);
-  task_tracker_ = other.task_tracker_;
-  other.task_tracker_ = nullptr;
+  task_tracker_ = std::exchange(other.task_tracker_, nullptr);
   return *this;
 }
 
+TaskSource::RunStatus RegisteredTaskSource::WillRunTask() {
+  TaskSource::RunStatus run_status = task_source_->WillRunTask();
+#if DCHECK_IS_ON()
+  DCHECK_EQ(run_step_, State::kInitial);
+  if (run_status != TaskSource::RunStatus::kDisallowed)
+    run_step_ = State::kReady;
+#endif  // DCHECK_IS_ON()
+  return run_status;
+}
+
+Optional<Task> RegisteredTaskSource::TakeTask(
+    TaskSource::Transaction* transaction) {
+  DCHECK(!transaction || transaction->task_source() == get());
+#if DCHECK_IS_ON()
+  DCHECK_EQ(State::kReady, run_step_);
+  run_step_ = State::kTaskAcquired;
+#endif  // DCHECK_IS_ON()
+  return task_source_->TakeTask(transaction);
+}
+
+Optional<Task> RegisteredTaskSource::Clear(
+    TaskSource::Transaction* transaction) {
+  DCHECK(!transaction || transaction->task_source() == get());
+#if DCHECK_IS_ON()
+  run_step_ = State::kInitial;
+#endif  // DCHECK_IS_ON()
+  return task_source_->Clear(transaction);
+}
+
+bool RegisteredTaskSource::DidProcessTask(
+    TaskSource::Transaction* transaction) {
+  DCHECK(!transaction || transaction->task_source() == get());
+#if DCHECK_IS_ON()
+  DCHECK_EQ(State::kTaskAcquired, run_step_);
+  run_step_ = State::kInitial;
+#endif  // DCHECK_IS_ON()
+  return task_source_->DidProcessTask(transaction);
+}
+
 RegisteredTaskSource::RegisteredTaskSource(
     scoped_refptr<TaskSource> task_source,
     TaskTracker* task_tracker)
     : task_source_(std::move(task_source)), task_tracker_(task_tracker) {}
 
+TransactionWithRegisteredTaskSource::TransactionWithRegisteredTaskSource(
+    RegisteredTaskSource task_source_in,
+    TaskSource::Transaction transaction_in)
+    : task_source(std::move(task_source_in)),
+      transaction(std::move(transaction_in)) {
+  DCHECK_EQ(task_source.get(), transaction.task_source());
+}
+
+// static:
+TransactionWithRegisteredTaskSource
+TransactionWithRegisteredTaskSource::FromTaskSource(
+    RegisteredTaskSource task_source_in) {
+  auto transaction = task_source_in->BeginTransaction();
+  return TransactionWithRegisteredTaskSource(std::move(task_source_in),
+                                             std::move(transaction));
+}
+
 }  // namespace internal
 }  // namespace base