[Reland] Dont post delayed DoWork for disabled queues.

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

 // 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.
 
 #ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_MANAGER_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_MANAGER_H_
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 56 matching lines @@
   // Requests that a task to process work is posted on the main task runner.
   // These tasks are de-duplicated in two buckets: main-thread and all other
   // threads.  This distinction is done to reduce the overehead from locks, we
   // assume the main-thread path will be hot.
   void MaybeScheduleImmediateWork(const tracked_objects::Location& from_here);
 
   // Requests that a delayed task to process work is posted on the main task
   // runner. These delayed tasks are de-duplicated. Must be called on the thread
   // this class was created on.
   void MaybeScheduleDelayedWork(const tracked_objects::Location& from_here,
-                                base::TimeTicks now,
-                                base::TimeDelta delay);
+                                TimeDomain* requesting_time_domain,
+                                LazyNow* lazy_now,
+                                base::TimeTicks run_time);
+
+  // Cancels a delayed task to process work at |run_time|, previously requested
+  // with MaybeScheduleDelayedWork.
+  void CancelDelayedWork(TimeDomain* requesting_time_domain,
+                         base::TimeTicks run_time);
 
   // Set the number of tasks executed in a single invocation of the task queue
   // manager. Increasing the batch size can reduce the overhead of yielding
   // back to the main message loop -- at the cost of potentially delaying other
   // tasks posted to the main loop. The batch size is 1 by default.
   void SetWorkBatchSize(int work_batch_size);
 
   // These functions can only be called on the same thread that the task queue
   // manager executes its tasks on.
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer);
@@ skipping 53 matching lines @@
   // Returns true if there is a task that could be executed immediately.
   bool HasImmediateWorkForTesting() const;
 
   // Removes all canceled delayed tasks.
   void SweepCanceledDelayedTasks();
 
   // There is a small overhead to recording task delay histograms. If you don't
   // need them, you can turn them off.
   void SetRecordTaskDelayHistograms(bool record_task_delay_histograms);
 
+  // Intermediate data structure, used to compute NextDelayedDoWork.
+  // Only public for testing.
+  class NextTaskDelay {

[Sami, 2017/02/01 07:30:05]

TaskQueueManagerTest is a friend -- could these two be private instead?

[alex clarke (OOO till 29th), 2017/02/01 14:50:11]

I found a way for NextDelayedDoWork to be private and NextTaskDelay to be
protected.

+   public:
+    NextTaskDelay() : time_domain_(nullptr) {}
+
+    NextTaskDelay(base::TimeDelta delay, TimeDomain* time_domain)
+        : delay_(delay), time_domain_(time_domain) {
+      DCHECK_GT(delay, base::TimeDelta());
+      DCHECK(time_domain);
+    }
+
+    base::TimeDelta delay() const { return delay_; }
+    TimeDomain* time_domain() const { return time_domain_; }
+
+    bool operator<(const NextTaskDelay& other) const {
+      return delay_ < other.delay_;
+    }
+
+   private:
+    base::TimeDelta delay_;
+    TimeDomain* time_domain_;
+  };
+
+  // Represents a scheduled delayed DoWork (if any). Only public for testing.
+  class NextDelayedDoWork {
+   public:
+    NextDelayedDoWork() : time_domain_(nullptr) {}
+    NextDelayedDoWork(base::TimeTicks run_time, TimeDomain* time_domain)
+        : run_time_(run_time), time_domain_(time_domain) {
+      DCHECK_NE(run_time, base::TimeTicks());
+      DCHECK(time_domain);
+    }
+
+    base::TimeTicks run_time() const { return run_time_; }
+    TimeDomain* time_domain() const { return time_domain_; }
+
+    void Clear() {
+      run_time_ = base::TimeTicks();
+      time_domain_ = nullptr;
+    }
+
+    explicit operator bool() const { return !run_time_.is_null(); }
+
+   private:
+    base::TimeTicks run_time_;
+    TimeDomain* time_domain_;
+  };
+
  private:
   friend class LazyNow;
   friend class internal::TaskQueueImpl;
   friend class TaskQueueManagerTest;
 
   class DeletionSentinel : public base::RefCounted<DeletionSentinel> {
    private:
     friend class base::RefCounted<DeletionSentinel>;
     ~DeletionSentinel() {}
   };
 
   // Unregisters a TaskQueue previously created by |NewTaskQueue()|.
   void UnregisterTaskQueue(scoped_refptr<internal::TaskQueueImpl> task_queue);
 
   // TaskQueueSelector::Observer implementation:
   void OnTaskQueueEnabled(internal::TaskQueueImpl* queue) override;
   void OnTriedToSelectBlockedWorkQueue(
       internal::WorkQueue* work_queue) override;
 
   // base::MessageLoop::NestingObserver implementation:
   void OnBeginNestedMessageLoop() override;
 
   // Called by the task queue to register a new pending task.
   void DidQueueTask(const internal::TaskQueueImpl::Task& pending_task);
 
   // Use the selector to choose a pending task and run it.
   void DoWork(bool delayed);
 
   // Post a DoWork continuation if |next_delay| is not empty.
-  void PostDoWorkContinuationLocked(base::Optional<base::TimeDelta> next_delay,
+  void PostDoWorkContinuationLocked(base::Optional<NextTaskDelay> next_delay,
                                     LazyNow* lazy_now,
                                     MoveableAutoLock&& lock);
 
   // Delayed Tasks with run_times <= Now() are enqueued onto the work queue and
   // reloads any empty work queues.
   void WakeupReadyDelayedQueues(LazyNow* lazy_now);
 
   // Chooses the next work queue to service. Returns true if |out_queue|
   // indicates the queue from which the next task should be run, false to
   // avoid running any tasks.
@@ skipping 17 matching lines @@
 
   bool RunsTasksOnCurrentThread() const;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay);
 
   internal::EnqueueOrder GetNextSequenceNumber();
 
   // Calls DelayTillNextTask on all time domains and returns the smallest delay
   // requested if any.
-  base::Optional<base::TimeDelta> ComputeDelayTillNextTaskLocked(
+  base::Optional<NextTaskDelay> ComputeDelayTillNextTaskLocked(
       LazyNow* lazy_now);
 
   void MaybeRecordTaskDelayHistograms(
       const internal::TaskQueueImpl::Task& pending_task,
       const internal::TaskQueueImpl* queue);
 
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
   AsValueWithSelectorResult(bool should_run,
                             internal::WorkQueue* selected_work_queue) const;
 
@@ skipping 56 matching lines @@
 
   struct AnyThread& any_thread() {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
   const struct AnyThread& any_thread() const {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
 
-  base::TimeTicks next_scheduled_delayed_do_work_time_;
+  NextDelayedDoWork next_delayed_do_work_;
 
   bool record_task_delay_histograms_;
 
   int work_batch_size_;
   size_t task_count_;
 
   base::ObserverList<base::MessageLoop::TaskObserver> task_observers_;
 
   base::ObserverList<TaskTimeObserver> task_time_observers_;
 
   const char* tracing_category_;
   const char* disabled_by_default_tracing_category_;
   const char* disabled_by_default_verbose_tracing_category_;
 
   internal::TaskQueueImpl* currently_executing_task_queue_;  // NOT OWNED
 
   Observer* observer_;  // NOT OWNED
   scoped_refptr<DeletionSentinel> deletion_sentinel_;
   base::WeakPtrFactory<TaskQueueManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueManager);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_MANAGER_H_