Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.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 140 matching lines @@
 
 void HTMLScriptRunner::detach()
 {
     if (!m_document)
         return;
 
     m_parserBlockingScript->stopWatchingForLoad();
     m_parserBlockingScript->releaseElementAndClear();
 
     while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
-        OwnPtrWillBeRawPtr<PendingScript> pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
+        RawPtr<PendingScript> pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
         pendingScript->stopWatchingForLoad();
         pendingScript->releaseElementAndClear();
     }
     m_document = nullptr;
 }
 
 bool HTMLScriptRunner::isPendingScriptReady(const PendingScript* script)
 {
     m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
     if (m_hasScriptsWaitingForResources)
@@ skipping 25 matching lines @@
         if (pendingScriptType == ScriptStreamer::ParsingBlocking) {
             m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
             // The parser cannot be unblocked as a microtask requested another resource
             if (m_hasScriptsWaitingForResources)
                 return;
         }
     }
 
     TextPosition scriptStartPosition = pendingScript->startingPosition();
     // Clear the pending script before possible re-entrancy from executeScript()
-    RefPtrWillBeRawPtr<Element> element = pendingScript->releaseElementAndClear();
+    RawPtr<Element> element = pendingScript->releaseElementAndClear();
     if (ScriptLoader* scriptLoader = toScriptLoaderIfPossible(element.get())) {
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
         IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(m_document);
         if (errorOccurred) {
             TRACE_EVENT_WITH_FLOW1("blink", "HTMLScriptRunner ExecuteScriptFailed", element.get(), TRACE_EVENT_FLAG_FLOW_IN,
                 "data", getTraceArgsForScriptElement(element.get(), scriptStartPosition));
             scriptLoader->dispatchErrorEvent();
         } else {
             ASSERT(isExecutingScript());
             if (!doExecuteScript(element.get(), sourceCode, scriptStartPosition)) {
@@ skipping 34 matching lines @@
     if (isExecutingScript() && cachedResource->wasCanceled()) {
         stopWatchingResourceForLoad(cachedResource);
         return;
     }
     m_host->notifyScriptLoaded(cachedResource);
 }
 
 // Implements the steps for 'An end tag whose tag name is "script"'
 // http://whatwg.org/html#scriptEndTag
 // Script handling lives outside the tree builder to keep each class simple.
-void HTMLScriptRunner::execute(PassRefPtrWillBeRawPtr<Element> scriptElement, const TextPosition& scriptStartPosition)
+void HTMLScriptRunner::execute(RawPtr<Element> scriptElement, const TextPosition& scriptStartPosition)
 {
     ASSERT(scriptElement);
     TRACE_EVENT1("blink", "HTMLScriptRunner::execute",
         "data", getTraceArgsForScriptElement(scriptElement.get(), scriptStartPosition));
     // FIXME: If scripting is disabled, always just return.
 
     bool hadPreloadScanner = m_host->hasPreloadScanner();
 
     // Try to execute the script given to us.
     runScript(scriptElement.get(), scriptStartPosition);
@@ skipping 49 matching lines @@
     TRACE_EVENT0("blink", "HTMLScriptRunner::executeScriptsWaitingForParsing");
     while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
         ASSERT(!isExecutingScript());
         ASSERT(!hasParserBlockingScript());
         ASSERT(m_scriptsToExecuteAfterParsing.first()->resource());
         if (!m_scriptsToExecuteAfterParsing.first()->isReady()) {
             m_scriptsToExecuteAfterParsing.first()->watchForLoad(this);
             traceParserBlockingScript(m_scriptsToExecuteAfterParsing.first().get(), !m_document->isScriptExecutionReady());
             return false;
         }
-        OwnPtrWillBeRawPtr<PendingScript> first = m_scriptsToExecuteAfterParsing.takeFirst();
+        RawPtr<PendingScript> first = m_scriptsToExecuteAfterParsing.takeFirst();
         executePendingScriptAndDispatchEvent(first.get(), ScriptStreamer::Deferred);
         // FIXME: What is this m_document check for?
         if (!m_document)
             return false;
     }
     return true;
 }
 
 void HTMLScriptRunner::requestParsingBlockingScript(Element* element)
 {
@@ skipping 11 matching lines @@
             if (scriptState)
                 ScriptStreamer::startStreaming(m_parserBlockingScript.get(), ScriptStreamer::ParsingBlocking, m_document->frame()->settings(), scriptState, m_document->loadingTaskRunner());
         }
 
         m_parserBlockingScript->watchForLoad(this);
     }
 }
 
 void HTMLScriptRunner::requestDeferredScript(Element* element)
 {
-    OwnPtrWillBeRawPtr<PendingScript> pendingScript = PendingScript::create(nullptr, nullptr);
+    RawPtr<PendingScript> pendingScript = PendingScript::create(nullptr, nullptr);
     if (!requestPendingScript(pendingScript.get(), element))
         return;
 
     if (m_document->frame() && !pendingScript->isReady()) {
         ScriptState* scriptState = ScriptState::forMainWorld(m_document->frame());
         if (scriptState)
             ScriptStreamer::startStreaming(pendingScript.get(), ScriptStreamer::Deferred, m_document->frame()->settings(), scriptState, m_document->loadingTaskRunner());
     }
 
     ASSERT(pendingScript->resource());
@@ skipping 64 matching lines @@
 
 DEFINE_TRACE(HTMLScriptRunner)
 {
     visitor->trace(m_document);
     visitor->trace(m_host);
     visitor->trace(m_parserBlockingScript);
     visitor->trace(m_scriptsToExecuteAfterParsing);
 }
 
 } // namespace blink