[Blink-Worker] WorkerThread fires idleHandler only at the end of processing all tasks.

Source/core/workers/WorkerThread.h

 /*
  * 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 40 matching lines @@
 class WorkerThreadShutdownFinishTask;
 class WorkerThreadStartupData;
 class WorkerThreadTask;
 
 enum WorkerThreadStartMode {
     DontPauseWorkerGlobalScopeOnStart,
     PauseWorkerGlobalScopeOnStart
 };
 
 class WorkerThread : public RefCounted<WorkerThread> {
+
+    class WorkerThreadTask : public blink::WebThread::Task {
+    WTF_MAKE_NONCOPYABLE(WorkerThreadTask); WTF_MAKE_FAST_ALLOCATED;
+    public:
+        static PassOwnPtr<WorkerThreadTask> create(WorkerThread&
+        , PassOwnPtr<ExecutionContextTask>, bool);
+
+        virtual ~WorkerThreadTask() { }
+        virtual void run() override;
+
+        void setIsIdleHandlerTask(bool isIdleHandlerTask) { m_isIdleHandlerTask = isIdleHandlerTask; }
+        bool isIdleHandlerTask() const { return m_isIdleHandlerTask; }
+        void cancelTask() { m_isTaskCanceled = true; };
+        double creationTimeStamp() const { return m_timeStamp; }
+
+    private:
+        WorkerThreadTask(WorkerThread&, PassOwnPtr<ExecutionContextTask>, bool);
+
+        WorkerThread& m_workerThread;
+        OwnPtr<ExecutionContextTask> m_task;
+        bool m_isInstrumented;
+        bool m_isIdleHandlerTask;
+        bool m_isTaskCanceled;
+        // Creation time stamp
+        double m_timeStamp;
+    };
+
 public:
     virtual ~WorkerThread();
 
     virtual void start();
     virtual void stop();
 
     // Can be used to wait for this worker thread to shut down.
     // (This is signalled on the main thread, so it's assumed to be waited on the worker context thread)
     WebWaitableEvent* shutdownEvent() { return m_shutdownEvent.get(); }
 
@@ skipping 20 matching lines @@
 
     // Number of active worker threads.
     static unsigned workerThreadCount();
 
     PlatformThreadId platformThreadId() const;
 
     void interruptAndDispatchInspectorCommands();
     void setWorkerInspectorController(WorkerInspectorController*);
 
 protected:
+    int decrementAndReturnTaskCount();
+    void queueUpIdleHandlerNow(long long delayMs);
+    int taskCount() { return m_tasksCount; }
+
     WorkerThread(WorkerLoaderProxy&, WorkerReportingProxy&, PassOwnPtrWillBeRawPtr<WorkerThreadStartupData>);
 
     // Factory method for creating a new worker context for the thread.
     virtual PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtrWillBeRawPtr<WorkerThreadStartupData>) = 0;
 
     virtual void postInitialize() { }
 
 private:
     friend class WorkerSharedTimer;
     friend class WorkerThreadShutdownFinishTask;
 
     void stopInShutdownSequence();
     void stopInternal();
 
     void initialize();
     void cleanup();
     void idleHandler();
     void postDelayedTask(PassOwnPtr<ExecutionContextTask>, long long delayMs);
+    // Method returns true if the task is canceled & cleared, else returns false
+    inline bool clearIdleHandlerTaskIfSet();
 
     bool m_terminated;
     OwnPtr<WorkerSharedTimer> m_sharedTimer;
     MessageQueue<WorkerThreadTask> m_debuggerMessageQueue;
     OwnPtr<WebThread::TaskObserver> m_microtaskRunner;
 
     WorkerLoaderProxy& m_workerLoaderProxy;
     WorkerReportingProxy& m_workerReportingProxy;
 
     RefPtrWillBePersistent<WorkerInspectorController> m_workerInspectorController;
     Mutex m_workerInspectorControllerMutex;
 
     Mutex m_threadCreationMutex;
     RefPtrWillBePersistent<WorkerGlobalScope> m_workerGlobalScope;
     OwnPtrWillBePersistent<WorkerThreadStartupData> m_startupData;
 
     // Used to signal thread shutdown.
     OwnPtr<WebWaitableEvent> m_shutdownEvent;
 
     // Used to signal thread termination.
     OwnPtr<WebWaitableEvent> m_terminationEvent;
 
+    WorkerThreadTask* m_lastQueuedIdleHandlerTask;
+    volatile int m_tasksCount;
+
     // FIXME: This has to be last because of crbug.com/401397 - the
     // WorkerThread might get deleted before it had a chance to properly
     // shut down. By deleting the WebThread first, we can guarantee that
     // no pending tasks on the thread might want to access any of the other
     // members during the WorkerThread's destruction.
     OwnPtr<WebThreadSupportingGC> m_thread;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h