Scheduler: Deprecate CancellableTaskFactory in favor of WebTaskRunner::postCancellableTask (2)

third_party/WebKit/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 42 matching lines @@
 }
 
 void SpeculationsPumpSession::addedElementTokens(size_t count) {
   m_processedElementTokens += count;
 }
 
 HTMLParserScheduler::HTMLParserScheduler(HTMLDocumentParser* parser,
                                          WebTaskRunner* loadingTaskRunner)
     : m_parser(parser),
       m_loadingTaskRunner(loadingTaskRunner->clone()),
-      m_cancellableContinueParse(CancellableTaskFactory::create(
-          this,
-          &HTMLParserScheduler::continueParsing)),
       m_isSuspendedWithActiveTimer(false) {}
 
 HTMLParserScheduler::~HTMLParserScheduler() {}
 
 DEFINE_TRACE(HTMLParserScheduler) {
   visitor->trace(m_parser);
 }
 
+bool HTMLParserScheduler::isScheduledForResume() const {
+  return m_isSuspendedWithActiveTimer ||
+         m_cancellableContinueParseTaskHandle.isActive();
+}
+
 void HTMLParserScheduler::scheduleForResume() {
-  ASSERT(!m_isSuspendedWithActiveTimer);
-  m_loadingTaskRunner->postTask(BLINK_FROM_HERE,
-                                m_cancellableContinueParse->cancelAndCreate());
+  DCHECK(!m_isSuspendedWithActiveTimer);
+  // wrapWeakPersistent(this) is safe because a posted task is canceled when the
+  // task handle is destroyed on the dtor of this HTMLParserScheduler.

[tzik, 2016/11/17 06:20:15]

ditto

[nhiroki, 2016/11/17 08:10:16]

Done.

+  m_cancellableContinueParseTaskHandle =
+      m_loadingTaskRunner->postCancellableTask(
+          BLINK_FROM_HERE, WTF::bind(&HTMLParserScheduler::continueParsing,
+                                     wrapWeakPersistent(this)));
 }
 
 void HTMLParserScheduler::suspend() {
-  ASSERT(!m_isSuspendedWithActiveTimer);
-  if (!m_cancellableContinueParse->isPending())
+  DCHECK(!m_isSuspendedWithActiveTimer);
+  if (!m_cancellableContinueParseTaskHandle.isActive())
     return;
   m_isSuspendedWithActiveTimer = true;
-  m_cancellableContinueParse->cancel();
+  m_cancellableContinueParseTaskHandle.cancel();
 }
 
 void HTMLParserScheduler::resume() {
-  ASSERT(!m_cancellableContinueParse->isPending());
+  DCHECK(!m_cancellableContinueParseTaskHandle.isActive());
   if (!m_isSuspendedWithActiveTimer)
     return;
   m_isSuspendedWithActiveTimer = false;
-
-  m_loadingTaskRunner->postTask(BLINK_FROM_HERE,
-                                m_cancellableContinueParse->cancelAndCreate());
+  scheduleForResume();
 }
 
 void HTMLParserScheduler::detach() {
-  m_cancellableContinueParse->cancel();
+  m_cancellableContinueParseTaskHandle.cancel();
   m_isSuspendedWithActiveTimer = false;
 }
 
 inline bool HTMLParserScheduler::shouldYield(
     const SpeculationsPumpSession& session,
     bool startingScript) const {
   if (Platform::current()
           ->currentThread()
           ->scheduler()
           ->shouldYieldForHighPriorityWork())
@@ skipping 22 matching lines @@
                                         bool startingScript) {
   if (shouldYield(session, startingScript)) {
     scheduleForResume();
     return true;
   }
 
   return false;
 }
 
 void HTMLParserScheduler::forceResumeAfterYield() {
-  ASSERT(!m_cancellableContinueParse->isPending());
+  DCHECK(!m_cancellableContinueParseTaskHandle.isActive());
   m_isSuspendedWithActiveTimer = true;
 }
 
 void HTMLParserScheduler::continueParsing() {
   m_parser->resumeParsingAfterYield();
 }
 
 }  // namespace blink