Implement timers by posting delayed tasks

This patch refactors TimerBase to post tasks delayed tasks and
deletes the now-obsolete timer heap and shared timer mechanism.

ATTN Sheriffs: If there are weird layout test flakes all of a
sudden, this patch may be the cause since the interleaving of
timers with other posted tasks will change.

Original patch by Alex Clarke <alexclarke@chromium.org>.

BUG=463143,416362,480522

Review URL: https://codereview.chromium.org/1134523002

git-svn-id: svn://svn.chromium.org/blink/trunk@195706 bbb929c8-8fbe-4397-9dbb-9b2b20218538

Author: skyostil

third_party/WebKit/Source/core/Init.cpp

@@ -54,7 +54,6 @@
 #include "core/workers/WorkerThread.h"
 #include "platform/EventTracer.h"
 #include "platform/FontFamilyNames.h"
-#include "platform/PlatformThreadData.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "wtf/Partitions.h"
@@ -110,10 +109,6 @@ void CoreInitializer::init()
 
     registerEventFactory();
 
-    // Ensure that the main thread's thread-local data is initialized before
-    // starting any worker threads.
-    PlatformThreadData::current();
-
     StringImpl::freezeStaticStrings();
 
     // Creates HTMLParserThread::shared and ScriptStreamerThread::shared, but

third_party/WebKit/Source/core/animation/CompositorAnimationsTestHelper.h

@@ -142,7 +142,7 @@ class AnimationCompositorAnimationsTestBase : public ::testing::Test {
 private:
     class PlatformProxy : public Platform {
     public:
-        PlatformProxy(WebCompositorSupportMock** compositor) : m_compositor(compositor) { }
+        PlatformProxy(WebCompositorSupportMock** compositor) : m_oldPlatform(blink::Platform::current()), m_compositor(compositor) { }
 
         virtual void cryptographicallyRandomValues(unsigned char* buffer, size_t length) { ASSERT_NOT_REACHED(); }
         const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
@@ -151,7 +151,13 @@ class AnimationCompositorAnimationsTestBase : public ::testing::Test {
             return &tracingIsDisabled;
         }
 
+        WebThread* currentThread() override
+        {
+            return m_oldPlatform->currentThread();
+        }
+
     private:
+        blink::Platform* m_oldPlatform; // Not owned.
         WebCompositorSupportMock** m_compositor;
         virtual WebCompositorSupport* compositorSupport() override { return *m_compositor; }
     };

third_party/WebKit/Source/core/fetch/CachingCorrectnessTest.cpp

@@ -124,7 +124,7 @@ class CachingCorrectnessTest : public ::testing::Test {
     // A simple platform that mocks out the clock, for cache freshness testing.
     class ProxyPlatform : public blink::Platform {
     public:
-        ProxyPlatform() : m_elapsedSeconds(0.) { }
+        ProxyPlatform() : m_oldPlatform(blink::Platform::current()), m_elapsedSeconds(0.) { }
 
         void advanceClock(double seconds)
         {
@@ -145,6 +145,12 @@ class CachingCorrectnessTest : public ::testing::Test {
             return &kAConstUnsignedCharZero;
         }
 
+        WebThread* currentThread() override
+        {
+            return m_oldPlatform->currentThread();
+        }
+
+        blink::Platform* m_oldPlatform; // Not owned.
         double m_elapsedSeconds;
     };
 

third_party/WebKit/Source/core/fetch/ResourceTest.cpp

@@ -22,7 +22,7 @@ namespace {
 
 class MockPlatform final : public Platform {
 public:
-    MockPlatform() { }
+    MockPlatform() : m_oldPlatform(Platform::current()) { }
     ~MockPlatform() override { }
 
     // From blink::Platform:
@@ -40,7 +40,13 @@ class MockPlatform final : public Platform {
         return m_cachedURLs;
     }
 
+    WebThread* currentThread() override
+    {
+        return m_oldPlatform->currentThread();
+    }
+
 private:
+    Platform* m_oldPlatform; // Not owned.
     Vector<WebURL> m_cachedURLs;
 };
 

third_party/WebKit/Source/core/frame/DOMTimerCoordinator.cpp

@@ -43,8 +43,9 @@ void DOMTimerCoordinator::removeTimeoutByID(int timeoutID)
 
 void DOMTimerCoordinator::didChangeTimerAlignmentInterval()
 {
+    double now = monotonicallyIncreasingTime();
     for (TimeoutMap::iterator iter = m_timers.begin(); iter != m_timers.end(); ++iter)
-        iter->value->didChangeAlignmentInterval();
+        iter->value->didChangeAlignmentInterval(now);
 }
 
 DEFINE_TRACE(DOMTimerCoordinator)

third_party/WebKit/Source/core/workers/WorkerThread.cpp

@@ -38,10 +38,8 @@
 #include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
-#include "platform/PlatformThreadData.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
-#include "platform/ThreadTimers.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/weborigin/KURL.h"
@@ -111,100 +109,6 @@ unsigned WorkerThread::workerThreadCount()
     return workerThreads().size();
 }
 
-class WorkerThreadCancelableTask final : public ExecutionContextTask {
-    WTF_MAKE_NONCOPYABLE(WorkerThreadCancelableTask); WTF_MAKE_FAST_ALLOCATED(WorkerThreadCancelableTask);
-public:
-    static PassOwnPtr<WorkerThreadCancelableTask> create(PassOwnPtr<Closure> closure)
-    {
-        return adoptPtr(new WorkerThreadCancelableTask(closure));
-    }
-
-    virtual ~WorkerThreadCancelableTask() { }
-
-    virtual void performTask(ExecutionContext*) override
-    {
-        if (!m_taskCanceled)
-            (*m_closure)();
-    }
-
-    WeakPtr<WorkerThreadCancelableTask> createWeakPtr() { return m_weakFactory.createWeakPtr(); }
-    void cancelTask() { m_taskCanceled = true; }
-
-private:
-    explicit WorkerThreadCancelableTask(PassOwnPtr<Closure> closure)
-        : m_closure(closure)
-        , m_weakFactory(this)
-        , m_taskCanceled(false)
-    { }
-
-    OwnPtr<Closure> m_closure;
-    WeakPtrFactory<WorkerThreadCancelableTask> m_weakFactory;
-    bool m_taskCanceled;
-};
-
-class WorkerSharedTimer : public SharedTimer {
-public:
-    explicit WorkerSharedTimer(WorkerThread* workerThread)
-        : m_workerThread(workerThread)
-        , m_running(false)
-    { }
-
-    typedef void (*SharedTimerFunction)();
-    virtual void setFiredFunction(SharedTimerFunction func)
-    {
-        m_sharedTimerFunction = func;
-    }
-
-    virtual void setFireInterval(double interval)
-    {
-        ASSERT(m_sharedTimerFunction);
-
-        // See BlinkPlatformImpl::setSharedTimerFireInterval for explanation of
-        // why ceil is used in the interval calculation.
-        int64_t delay = static_cast<int64_t>(ceil(interval * 1000));
-
-        if (delay < 0) {
-            delay = 0;
-        }
-
-        m_running = true;
-
-        if (m_lastQueuedTask.get())
-            m_lastQueuedTask->cancelTask();
-
-        // Now queue the task as a cancellable one.
-        OwnPtr<WorkerThreadCancelableTask> task = WorkerThreadCancelableTask::create(bind(&WorkerSharedTimer::OnTimeout, this));
-        m_lastQueuedTask = task->createWeakPtr();
-        m_workerThread->postDelayedTask(FROM_HERE, task.release(), delay);
-    }
-
-    virtual void stop()
-    {
-        m_running = false;
-        m_lastQueuedTask = nullptr;
-    }
-
-private:
-    void OnTimeout()
-    {
-        ASSERT(m_workerThread->workerGlobalScope());
-
-        m_lastQueuedTask = nullptr;
-
-        if (m_sharedTimerFunction && m_running && !m_workerThread->workerGlobalScope()->isClosing())
-            m_sharedTimerFunction();
-    }
-
-    WorkerThread* m_workerThread;
-    SharedTimerFunction m_sharedTimerFunction;
-    bool m_running;
-
-    // The task to run OnTimeout, if any. While OnTimeout resets
-    // m_lastQueuedTask, this must be a weak pointer because the
-    // worker runloop may delete the task as it is shutting down.
-    WeakPtr<WorkerThreadCancelableTask> m_lastQueuedTask;
-};
-
 class WorkerThreadTask : public WebThread::Task {
     WTF_MAKE_NONCOPYABLE(WorkerThreadTask); WTF_MAKE_FAST_ALLOCATED(WorkerThreadTask);
 public:
@@ -321,8 +225,6 @@ void WorkerThread::initialize(PassOwnPtr<WorkerThreadStartupData> startupData)
         m_isolate = initializeIsolate();
         m_workerGlobalScope = createWorkerGlobalScope(startupData);
         m_workerGlobalScope->scriptLoaded(sourceCode.length(), cachedMetaData.get() ? cachedMetaData->size() : 0);
-
-        PlatformThreadData::current().threadTimers().setSharedTimer(adoptPtr(new WorkerSharedTimer(this)));
     }
 
     // The corresponding call to stopRunLoop() is in ~WorkerScriptController().
@@ -356,7 +258,6 @@ void WorkerThread::shutdown()
         m_shutdown = true;
     }
 
-    PlatformThreadData::current().threadTimers().setSharedTimer(nullptr);
     workerGlobalScope()->dispose();
     willDestroyIsolate();
 
@@ -383,9 +284,6 @@ void WorkerThread::shutdown()
     workerReportingProxy().workerThreadTerminated();
 
     m_terminationEvent->signal();
-
-    // Clean up PlatformThreadData before WTF::WTFThreadData goes away!
-    PlatformThreadData::current().destroy();
 }
 
 

third_party/WebKit/Source/core/workers/WorkerThread.h

@@ -48,7 +48,6 @@ class WorkerGlobalScope;
 class WorkerInspectorController;
 class WorkerMicrotaskRunner;
 class WorkerReportingProxy;
-class WorkerSharedTimer;
 class WorkerThreadStartupData;
 
 enum WorkerThreadStartMode {
@@ -131,7 +130,6 @@ class CORE_EXPORT WorkerThread : public RefCounted<WorkerThread> {
     virtual bool doIdleGc(double deadlineSeconds);
 
 private:
-    friend class WorkerSharedTimer;
     friend class WorkerMicrotaskRunner;
 
     void stopInShutdownSequence();