[scheduler] Add TaskQueue::Observer

third_party/WebKit/Source/platform/scheduler/base/time_domain.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_TIME_DOMAIN_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_
 
 #include <map>
 
 #include "base/callback.h"
@@ skipping 18 matching lines @@
 // the wake up is due the TimeDomain calls TaskQueue::WakeUpForDelayedWork.
 // The TimeDomain communicates with the TaskQueueManager to actually schedule
 // the wake-ups on the underlying base::MessageLoop. Various levels of de-duping
 // are employed to prevent unnecessary posting of TaskQueueManager::DoWork.
 //
 // Note the TimeDomain only knows about the first wakeup per queue, it's the
 // responsibility of TaskQueueImpl to keep the time domain up to date if this
 // changes.
 class BLINK_PLATFORM_EXPORT TimeDomain {
  public:
-  class BLINK_PLATFORM_EXPORT Observer {
-   public:
-    virtual ~Observer() {}
-
-    // Called when an empty TaskQueue registered with this TimeDomain has a task
-    // enqueued.
-    // |task_queue| - task queue which has immediate work scheduled.
-    virtual void OnTimeDomainHasImmediateWork(TaskQueue* task_queue) = 0;
-
-    // Called when a TaskQueue registered with this TimeDomain has a delayed
-    // task enqueued.
-    // |task_queue| - task queue which has delayed work scheduled.
-    virtual void OnTimeDomainHasDelayedWork(TaskQueue* task_queue) = 0;
-  };
-
-  explicit TimeDomain(Observer* observer);
+  TimeDomain();
   virtual ~TimeDomain();
 
   // Returns a LazyNow that evaluate this TimeDomain's Now.  Can be called from
   // any thread.
   // TODO(alexclarke): Make this main thread only.
   virtual LazyNow CreateLazyNow() const = 0;
 
   // Evaluate this TimeDomain's Now. Can be called from any thread.
   virtual base::TimeTicks Now() const = 0;
 
@@ skipping 14 matching lines @@
  protected:
   friend class internal::TaskQueueImpl;
   friend class TaskQueueManager;
 
   void AsValueInto(base::trace_event::TracedValue* state) const;
 
   // If there is a scheduled delayed task, |out_task_queue| is set to the queue
   // the next task was posted to and it returns true.  Returns false otherwise.
   bool NextScheduledTaskQueue(TaskQueue** out_task_queue) const;
 
-  // Notifies the time domain observer (if any) that |queue| has incoming
-  // immediate work.
-  void OnQueueHasImmediateWork(internal::TaskQueueImpl* queue);
-
   // Schedules a call to TaskQueueImpl::WakeUpForDelayedWork when this
   // TimeDomain reaches |delayed_run_time|.  This supersedes any previously
   // registered wakeup for |queue|.
   void ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                            internal::TaskQueueImpl::DelayedWakeUp wake_up,
                            base::TimeTicks now);
 
   // Cancels any scheduled calls to TaskQueueImpl::WakeUpForDelayedWork for
   // |queue|.
   void CancelDelayedWork(internal::TaskQueueImpl* queue);
@@ skipping 51 matching lines @@
       DCHECK(queue->heap_handle().IsValid());
       queue->set_heap_handle(HeapHandle());
 
       DCHECK_NE(queue->scheduled_time_domain_wakeup(), base::TimeTicks());
       queue->set_scheduled_time_domain_wakeup(base::TimeTicks());
     }
   };
 
   IntrusiveHeap<ScheduledDelayedWakeUp> delayed_wakeup_queue_;
 
-  Observer* const observer_;  // NOT OWNED.
-
   base::ThreadChecker main_thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(TimeDomain);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_