[Blink-WebWorkers] WorkerSharedTimer cancels extra delayed tasks.

Source/core/workers/WorkerThread.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 67 matching lines @@
     DEFINE_STATIC_LOCAL(HashSet<WorkerThread*>, threads, ());
     return threads;
 }
 
 unsigned WorkerThread::workerThreadCount()
 {
     MutexLocker lock(threadSetMutex());
     return workerThreads().size();
 }
 
+class WorkerThreadCancelableTask FINAL : public ExecutionContextTask {
+    WTF_MAKE_NONCOPYABLE(WorkerThreadCancelableTask); WTF_MAKE_FAST_ALLOCATED;
+public:
+    static PassOwnPtr<WorkerThreadCancelableTask> create(const Closure& closure)
+    {
+        return adoptPtr(new WorkerThreadCancelableTask(closure));
+    }
+
+    virtual void performTask(ExecutionContext*) OVERRIDE
+    {
+        if (!m_taskCanceled)
+            m_closure();
+    }
+
+    void cancelTask() { m_taskCanceled = true; }
+
+private:
+    explicit WorkerThreadCancelableTask(const Closure& closure)
+    : m_closure(closure)
+    , m_taskCanceled(false)
+    { }
+
+    Closure m_closure;
+    bool m_taskCanceled;
+};
+
 class WorkerSharedTimer : public SharedTimer {
 public:
     explicit WorkerSharedTimer(WorkerThread* workerThread)
         : m_workerThread(workerThread)
         , m_nextFireTime(0.0)
         , m_running(false)
+        , m_lastQueuedTask(0)
+        , m_lastQueuedTaskTimer(0)
     { }
 
     typedef void (*SharedTimerFunction)();
     virtual void setFiredFunction(SharedTimerFunction func)
     {
         m_sharedTimerFunction = func;
         if (!m_sharedTimerFunction)
             m_nextFireTime = 0.0;
     }
 
     virtual void setFireInterval(double interval)
     {
         ASSERT(m_sharedTimerFunction);
 
         // See BlinkPlatformImpl::setSharedTimerFireInterval for explanation of
         // why ceil is used in the interval calculation.
         int64 delay = static_cast<int64>(ceil(interval * 1000));
 
         if (delay < 0) {
             delay = 0;
             m_nextFireTime = 0.0;
         }
 
         m_running = true;
         m_nextFireTime = currentTime() + interval;
-        m_workerThread->postDelayedTask(createSameThreadTask(&WorkerSharedTimer::OnTimeout, this), delay);
+        if (m_lastQueuedTask) {
+            // If something was queued up before this, check if its later than the current timer
+            if (m_lastQueuedTaskTimer->isActive()) {

[jochen (gone - plz use gerrit), 2014/09/19 13:37:09]

ok, if you want to go without posting a task for the time difference, we can
simplify this a bit:

get rid of m_lastQueuedTaskTimer, and just always cancel the currently queued
task

[Mayur Kankanwadi, 2014/09/19 13:53:24]

I am bit confused with this suggestion.
If we discard m_lastQueuedTaskTimer, how would we know if the top of heap timer
interval is greater or less than the currently passed timer interval. As it is
not mandatory that the interval sent across is smaller than that of the
previously queued task.

+                if (interval < m_lastQueuedTaskTimer->nextFireInterval()) {
+                    m_lastQueuedTask->cancelTask();
+                    m_lastQueuedTask = 0;
+                    m_lastQueuedTaskTimer = 0;
+                }
+            } else {
+                m_lastQueuedTask->cancelTask();
+                m_lastQueuedTask = 0;
+                m_lastQueuedTaskTimer = 0;
+            }
+        }
+        if (!m_lastQueuedTask) {
+            // Now queue the task as a cancellable one.
+            m_lastQueuedTask = WorkerThreadCancelableTask::create(bind(&WorkerSharedTimer::OnTimeout, this)).leakPtr();
+            m_workerThread->postDelayedTask(adoptPtr(m_lastQueuedTask), delay);
+            // The current timer should ideally be at the top of the heap as its assumed to be the smallest interval in the heap
+            m_lastQueuedTaskTimer = PlatformThreadData::current().threadTimers().timerHeap().first();
+        }
     }
 
     virtual void stop()
     {
         m_running = false;
+        if (m_lastQueuedTask)
+            m_lastQueuedTask->cancelTask();
+        m_lastQueuedTask = 0;
+        m_lastQueuedTaskTimer = 0;
     }
 
     double nextFireTime() { return m_nextFireTime; }
 
 private:
     void OnTimeout()
     {
         ASSERT(m_workerThread->workerGlobalScope());
+
+        m_lastQueuedTask = 0;
+        m_lastQueuedTaskTimer = 0;
+
         if (m_sharedTimerFunction && m_running && !m_workerThread->workerGlobalScope()->isClosing())
             m_sharedTimerFunction();
     }
 
     WorkerThread* m_workerThread;
     SharedTimerFunction m_sharedTimerFunction;
     double m_nextFireTime;
     bool m_running;
+    WorkerThreadCancelableTask* m_lastQueuedTask;
+    TimerBase* m_lastQueuedTaskTimer;
 };
 
 class WorkerThreadTask : public blink::WebThread::Task {
     WTF_MAKE_NONCOPYABLE(WorkerThreadTask); WTF_MAKE_FAST_ALLOCATED;
 public:
     static PassOwnPtr<WorkerThreadTask> create(const WorkerThread& workerThread, PassOwnPtr<ExecutionContextTask> task, bool isInstrumented)
     {
         return adoptPtr(new WorkerThreadTask(workerThread, task, isInstrumented));
     }
 
@@ skipping 345 matching lines @@
     InspectorInstrumentation::didLeaveNestedRunLoop(m_workerGlobalScope.get());
 }
 
 void WorkerThread::setWorkerInspectorController(WorkerInspectorController* workerInspectorController)
 {
     MutexLocker locker(m_workerInspectorControllerMutex);
     m_workerInspectorController = workerInspectorController;
 }
 
 } // namespace blink