[Reland] Dont post delayed DoWork for disabled queues.

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 200 matching lines @@
       return;
     }
 
     any_thread().immediate_do_work_posted_count++;
   }
   delegate_->PostTask(from_here, immediate_do_work_closure_);
 }
 
 void TaskQueueManager::MaybeScheduleDelayedWork(
     const tracked_objects::Location& from_here,
-    base::TimeTicks now,
-    base::TimeDelta delay) {
+    LazyNow* lazy_now,

[Sami, 2016/12/14 16:29:38]

Not something for this patch, but I'm feeling a little nervous about all the
LazyNows we're passing around. It feels like it's too easy to accidentally keep
a LazyNow around for too long (say, around task observers) and end up with time
skew as a result. I wonder if we should add some DCHECKs or another mechanism to
guard against that?

[alex clarke (OOO till 29th), 2016/12/14 16:50:36]

Agreed it would be easy for that to happen.  I'll have to think if there's
something we can do.

+    base::TimeTicks run_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  DCHECK_GE(delay, base::TimeDelta());
   {
     base::AutoLock lock(any_thread_lock_);
 
     // Unless we're nested, don't post a delayed DoWork if there's an immediate
     // DoWork in flight or we're inside a DoWork. We can rely on DoWork posting
     // a delayed continuation as needed.
     if (!any_thread().is_nested &&
         (any_thread().immediate_do_work_posted_count > 0 ||
          any_thread().do_work_running_count == 1)) {
       return;
     }
   }
 
   // De-duplicate DoWork posts.
-  base::TimeTicks run_time = now + delay;
   if (next_delayed_do_work_ <= run_time && !next_delayed_do_work_.is_null())
     return;
 
+  cancelable_delayed_do_work_closure_.Reset(delayed_do_work_closure_);
+
+  base::TimeDelta delay =
+      std::max(base::TimeDelta(), run_time - lazy_now->Now());
+  next_delayed_do_work_ = lazy_now->Now() + delay;
+
   TRACE_EVENT1(tracing_category_, "MaybeScheduleDelayedWorkInternal",
                "delay_ms", delay.InMillisecondsF());
 
-  cancelable_delayed_do_work_closure_.Reset(delayed_do_work_closure_);
-  next_delayed_do_work_ = run_time;
   delegate_->PostDelayedTask(
       from_here, cancelable_delayed_do_work_closure_.callback(), delay);
 }
 
+void TaskQueueManager::CancelDelayedWork(base::TimeTicks run_time) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  if (next_delayed_do_work_ != run_time)
+    return;
+
+  cancelable_delayed_do_work_closure_.Cancel();
+  next_delayed_do_work_ = base::TimeTicks();
+}
+
 void TaskQueueManager::DoWork(bool delayed) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT1("tracing_category_", "TaskQueueManager::DoWork", "delayed",
                delayed);
   LazyNow lazy_now(real_time_domain()->CreateLazyNow());
 
   bool is_nested = delegate_->IsNested();
   if (!is_nested)
     queues_to_delete_.clear();
 
@@ skipping 374 matching lines @@
 }
 
 void TaskQueueManager::SetRecordTaskDelayHistograms(
     bool record_task_delay_histograms) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   record_task_delay_histograms_ = record_task_delay_histograms;
 }
 
 }  // namespace scheduler
 }  // namespace blink