[scheduler] Change TaskQueue observer call mechanism.

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

 // Copyright 2015 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_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 159 matching lines @@
   void ReloadImmediateWorkQueueIfEmpty();
 
   void AsValueInto(base::trace_event::TracedValue* state) const;
 
   bool GetQuiescenceMonitored() const { return should_monitor_quiescence_; }
   bool GetShouldNotifyObservers() const { return should_notify_observers_; }
 
   void NotifyWillProcessTask(const base::PendingTask& pending_task);
   void NotifyDidProcessTask(const base::PendingTask& pending_task);
 
+  void SetScheduledTimeDomainWakeUp(
+      base::Optional<base::TimeTicks> scheduled_time_domain_wake_up);
+
+  // Check for pending immediate work, but do not look in
+  // delayed_incoming_queue.
+  // Used check if we need to generate notifications about delayed work.

[Sami, 2017/04/10 17:45:07]

"Used to check"?

[altimin, 2017/05/08 15:40:12]

Done.

+  bool HasPendingImmediateWorkWithoutDelayedIncomingQueue();

[Sami, 2017/04/10 17:45:07]

This name is pretty hard to parse. HasPendingNonDelayedWork or something?

Edit: looks like that's not really accurate either. Can you suggest a better
name?

[altimin, 2017/05/08 15:40:12]

HasPendingImmediateWork -> HasTasksToRunImmediately
HasPendingImmediateWorkWithoutDelayedIncomingQueue -> HasPendingImmediateWork

Done.

+
   WorkQueue* delayed_work_queue() {
     return main_thread_only().delayed_work_queue.get();
   }
 
   const WorkQueue* delayed_work_queue() const {
     return main_thread_only().delayed_work_queue.get();
   }
 
   WorkQueue* immediate_work_queue() {
     return main_thread_only().immediate_work_queue.get();
   }
 
   const WorkQueue* immediate_work_queue() const {
     return main_thread_only().immediate_work_queue.get();
   }
 
   bool should_report_when_execution_blocked() const {
     return should_report_when_execution_blocked_;
   }
 
   // Enqueues any delayed tasks which should be run now on the
   // |delayed_work_queue|. Returns the subsequent wake-up that is required, if
   // any. Must be called from the main thread.
   base::Optional<DelayedWakeUp> WakeUpForDelayedWork(LazyNow* lazy_now);
 
-  base::TimeTicks scheduled_time_domain_wake_up() const {
+  base::Optional<base::TimeTicks> scheduled_time_domain_wake_up() const {
     return main_thread_only().scheduled_time_domain_wake_up;
   }
 
-  void set_scheduled_time_domain_wake_up(
-      base::TimeTicks scheduled_time_domain_wake_up) {
-    main_thread_only().scheduled_time_domain_wake_up =
-        scheduled_time_domain_wake_up;
-  }
-
   HeapHandle heap_handle() const { return main_thread_only().heap_handle; }
 
   void set_heap_handle(HeapHandle heap_handle) {
     main_thread_only().heap_handle = heap_handle;
   }
 
   void PushImmediateIncomingTaskForTest(TaskQueueImpl::Task&& task);
   EnqueueOrder GetFenceForTest() const;
 
   class QueueEnabledVoterImpl : public QueueEnabledVoter {
@@ skipping 53 matching lines @@
     std::unique_ptr<WorkQueue> delayed_work_queue;
     std::unique_ptr<WorkQueue> immediate_work_queue;
     std::priority_queue<Task> delayed_incoming_queue;
     base::ObserverList<base::MessageLoop::TaskObserver> task_observers;
     size_t set_index;
     HeapHandle heap_handle;
     int is_enabled_refcount;
     int voter_refcount;
     base::trace_event::BlameContext* blame_context;  // Not owned.
     EnqueueOrder current_fence;
-    base::TimeTicks scheduled_time_domain_wake_up;
+    base::Optional<base::TimeTicks> scheduled_time_domain_wake_up;
   };
 
   ~TaskQueueImpl() override;
 
   bool PostImmediateTaskImpl(const tracked_objects::Location& from_here,
                              base::OnceClosure task,
                              TaskType task_type);
   bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                            base::OnceClosure task,
                            base::TimeDelta delay,
@@ skipping 34 matching lines @@
   static void TaskAsValueInto(const Task& task,
                               base::trace_event::TracedValue* state);
 
   void RemoveQueueEnabledVoter(const QueueEnabledVoterImpl* voter);
   void OnQueueEnabledVoteChanged(bool enabled);
   void EnableOrDisableWithSelector(bool enable);
 
   // Schedules delayed work on time domain and calls the observer.
   void ScheduleDelayedWorkInTimeDomain(base::TimeTicks now);
 
-  void NotifyWakeUpChangedOnMainThread(base::TimeTicks wake_up);
-
   const base::PlatformThreadId thread_id_;
 
   mutable base::Lock any_thread_lock_;
   AnyThread any_thread_;
   struct AnyThread& any_thread() {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
   const struct AnyThread& any_thread() const {
     any_thread_lock_.AssertAcquired();
@@ skipping 32 matching lines @@
   const bool should_report_when_execution_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_