Adds a CancellableTaskFactory and exposes postLoadingTasks to Blink

Source/core/html/parser/HTMLParserScheduler.cpp

 /*
  * Copyright (C) 2010 Google, 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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/parser/HTMLParserScheduler.h"
 
 #include "core/dom/Document.h"
 #include "core/html/parser/HTMLDocumentParser.h"
 #include "core/frame/FrameView.h"
 #include "platform/scheduler/Scheduler.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebTraceLocation.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 ActiveParserSession::ActiveParserSession(unsigned& nestingLevel, Document* document)
     : NestingLevelIncrementer(nestingLevel)
     , m_document(document)
 {
     if (!m_document)
         return;
@@ skipping 32 matching lines @@
     return currentTime() - m_startTime;
 }
 
 void SpeculationsPumpSession::addedElementTokens(size_t count)
 {
     m_processedElementTokens += count;
 }
 
 HTMLParserScheduler::HTMLParserScheduler(HTMLDocumentParser* parser)
     : m_parser(parser)
-    , m_continueNextChunkTimer(this, &HTMLParserScheduler::continueNextChunkTimerFired)
+    , m_cancelableContinueParse(WTF::bind(&HTMLDocumentParser::resumeParsingAfterYield, m_parser))
     , m_isSuspendedWithActiveTimer(false)
 {
 }
 
 HTMLParserScheduler::~HTMLParserScheduler()
 {
-    m_continueNextChunkTimer.stop();
-}
-
-void HTMLParserScheduler::continueNextChunkTimerFired(Timer<HTMLParserScheduler>* timer)
-{
-    ASSERT_UNUSED(timer, timer == &m_continueNextChunkTimer);
-    m_parser->resumeParsingAfterYield();
 }
 
 void HTMLParserScheduler::scheduleForResume()
 {
-    ASSERT(!m_isSuspendedWithActiveTimer);
-    m_continueNextChunkTimer.startOneShot(0, FROM_HERE);
+    Platform::current()->scheduler()->postLoadingTask(WebTraceLocation(FROM_HERE), m_cancelableContinueParse.task());
 }
 
 void HTMLParserScheduler::suspend()
 {
     ASSERT(!m_isSuspendedWithActiveTimer);
-    if (!m_continueNextChunkTimer.isActive())
+    if (!m_cancelableContinueParse.isPending())
         return;
     m_isSuspendedWithActiveTimer = true;
-    m_continueNextChunkTimer.stop();
+    m_cancelableContinueParse.cancel();
 }
 
 void HTMLParserScheduler::resume()
 {
-    ASSERT(!m_continueNextChunkTimer.isActive());
+    ASSERT(!m_cancelableContinueParse.isPending());
     if (!m_isSuspendedWithActiveTimer)
         return;
     m_isSuspendedWithActiveTimer = false;
-    m_continueNextChunkTimer.startOneShot(0, FROM_HERE);
+    Platform::current()->scheduler()->postLoadingTask(WebTraceLocation(FROM_HERE), m_cancelableContinueParse.task());

[Sami, 2015/01/26 17:18:34]

I think it's a little unfortunate that we need to reach into the platform here.
IMO WebScheduler should be the convenient interface for all clients to use and
the one in platform is just an implementation detail. Maybe the cancellable
factory should return a closure instead?

[alex clarke (OOO till 29th), 2015/01/26 17:31:35]

If we do that we'll have the following nested things:
* WTF::Bind closure posted to CancellableTaskFactory
* A WTF::Bind to call a new run method (the one we just deleted) on
CancellableTaskFactory
* An instance of ClosureRunner
* The chromium closure posted on the run loop.


If we keep it like this we'll have a slightly better situation with:
* WTF::Bind closure posted to CancellableTaskFactory
* The CancellableTask
* The chromium closure posted on the run loop.

 }
 
 inline bool HTMLParserScheduler::shouldYield(const SpeculationsPumpSession& session, bool startingScript) const
 {
     if (Scheduler::shared()->shouldYieldForHighPriorityWork())
         return true;
 
     const double parserTimeLimit = 0.5;
     if (session.elapsedTime() > parserTimeLimit)
         return true;
@@ skipping 18 matching lines @@
     if (shouldYield(session, startingScript)) {
         scheduleForResume();
         return true;
     }
 
     return false;
 }
 
 void HTMLParserScheduler::forceResumeAfterYield()
 {
-    ASSERT(!m_continueNextChunkTimer.isActive());
+    ASSERT(!m_cancelableContinueParse.isPending());
     m_isSuspendedWithActiveTimer = true;
 }
 
 }