Refactor TimeBase to post tasks. Workers to use real Idle 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 29 matching lines @@
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include <v8.h>
 
 namespace blink {
 
 class WebWaitableEvent;
 class WorkerGlobalScope;
 class WorkerInspectorController;
 class WorkerReportingProxy;
-class WorkerSharedTimer;
 class WorkerThreadShutdownFinishTask;
 class WorkerThreadStartupData;
 class WorkerThreadTask;
 
 enum WorkerThreadStartMode {
     DontPauseWorkerGlobalScopeOnStart,
     PauseWorkerGlobalScopeOnStart
 };
 
 class CORE_EXPORT WorkerThread : public RefCounted<WorkerThread> {
@@ skipping 54 matching lines @@
     // Factory method for creating a new worker context for the thread.
     virtual PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData>) = 0;
 
     virtual void postInitialize() { }
 
     virtual v8::Isolate* initializeIsolate();
     virtual void willDestroyIsolate();
     virtual void destroyIsolate();
     virtual void terminateV8Execution();
 
+    // This is protected virtual for testing.
+    virtual bool doIdleGc(double deadlineSeconds);
+
+    WebThreadSupportingGC* threadForTesting() const
+    {
+        return m_thread.get();
+    }
+
+    void setMinQuietPeriodBeforeDoingIdleGcForTesting(long long minQuietPeriodBeforeDoingIdleGc)

[Sami, 2015/04/09 10:52:29]

For better or worse, "double seconds" is the preferred monotonic time data type
in Blink. I'm not sure why delays use long long but IMO that shouldn't be needed
here (feel free to keep in long long internally if you want). Also please make
the unit obvious in the function and parameter names.

[alex clarke (OOO till 29th), 2015/04/10 15:29:38]

Acknowledged.

+    {
+        m_minQuietPeriodMsBeforeDoingIdleGc = minQuietPeriodBeforeDoingIdleGc;
+    }
+
 private:
-    friend class WorkerSharedTimer;
+    friend class WorkerThreadIdleTask;
     friend class WorkerThreadShutdownFinishTask;
+    friend class WorkerThreadWaitUntilIdleTask;
+    friend class WorkerThreadWakeupIdleTask;
 
     void stopInShutdownSequence();
     void stopInternal();
 
     void initialize();
     void cleanup();
-    void idleHandler();
+    void dontStartIdleTaskYet();

[Sami, 2015/04/09 10:52:29]

Okay, I think I agree that it's probably better not to talk about idle periods
here. However the naming could be a little more consistent since you don't
"start" tasks but either "post" or "run" them. How about
dontPostIdleTaskYet()/maybePostIdleTask(), or better yet:
dontStartIdleGcYet()/maybeStartIdleGc()/idleGc()?

[alex clarke (OOO till 29th), 2015/04/10 15:29:37]

Acknowledged.

+    void maybeStartIdleTask();
+    void idleTask(double deadlineSeconds);
     void postDelayedTask(PassOwnPtr<ExecutionContextTask>, long long delayMs);
     void postDelayedTask(const WebTraceLocation&, PassOwnPtr<ExecutionContextTask>, long long delayMs);
 
     bool m_terminated;
     MessageQueue<WorkerThreadTask> m_debuggerMessageQueue;
     OwnPtr<WebThread::TaskObserver> m_microtaskRunner;
 
     RefPtr<WorkerLoaderProxy> m_workerLoaderProxy;
     WorkerReportingProxy& m_workerReportingProxy;
 
     RefPtrWillBePersistent<WorkerInspectorController> m_workerInspectorController;
     Mutex m_workerInspectorControllerMutex;
 
     Mutex m_threadCreationMutex;
     RefPtrWillBePersistent<WorkerGlobalScope> m_workerGlobalScope;
     OwnPtr<WorkerThreadStartupData> m_startupData;
 
     v8::Isolate* m_isolate;
     OwnPtr<V8IsolateInterruptor> m_interruptor;
 
     // Used to signal thread shutdown.
     OwnPtr<WebWaitableEvent> m_shutdownEvent;
 
     // Used to signal thread termination.
     OwnPtr<WebWaitableEvent> m_terminationEvent;
 
+    long long m_minQuietPeriodMsBeforeDoingIdleGc;
+    bool m_dontStartIdleTaskYet;
+
     // 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