Migrate WTF::Deque::append() to ::push_back()

third_party/WebKit/Source/core/dom/ScriptRunner.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 40 matching lines @@
 void ScriptRunner::queueScriptForExecution(ScriptLoader* scriptLoader,
                                            AsyncExecutionType executionType) {
   DCHECK(scriptLoader);
   m_document->incrementLoadEventDelayCount();
   switch (executionType) {
     case Async:
       m_pendingAsyncScripts.insert(scriptLoader);
       break;
 
     case InOrder:
-      m_pendingInOrderScripts.append(scriptLoader);
+      m_pendingInOrderScripts.push_back(scriptLoader);
       m_numberOfInOrderScriptsWithPendingNotification++;
       break;
     case None:
       NOTREACHED();
       break;
   }
 }
 
 void ScriptRunner::postTask(const WebTraceLocation& webTraceLocation) {
   m_taskRunner->postTask(webTraceLocation, WTF::bind(&ScriptRunner::executeTask,
@@ skipping 21 matching lines @@
   }
 }
 
 void ScriptRunner::scheduleReadyInOrderScripts() {
   while (!m_pendingInOrderScripts.isEmpty() &&
          m_pendingInOrderScripts.first()->isReady()) {
     // A ScriptLoader that failed is responsible for cancelling itself
     // notifyScriptLoadError(); it continues this draining of ready scripts.
     if (m_pendingInOrderScripts.first()->errorOccurred())
       break;
-    m_inOrderScriptsToExecuteSoon.append(m_pendingInOrderScripts.takeFirst());
+    m_inOrderScriptsToExecuteSoon.push_back(
+        m_pendingInOrderScripts.takeFirst());
     postTask(BLINK_FROM_HERE);
   }
 }
 
 void ScriptRunner::notifyScriptReady(ScriptLoader* scriptLoader,
                                      AsyncExecutionType executionType) {
   SECURITY_CHECK(scriptLoader);
   switch (executionType) {
     case Async:
       // SECURITY_CHECK() makes us crash in a controlled way in error cases
       // where the ScriptLoader is associated with the wrong ScriptRunner
       // (otherwise we'd cause a use-after-free in ~ScriptRunner when it tries
       // to detach).
       SECURITY_CHECK(m_pendingAsyncScripts.contains(scriptLoader));
 
       m_pendingAsyncScripts.erase(scriptLoader);
-      m_asyncScriptsToExecuteSoon.append(scriptLoader);
+      m_asyncScriptsToExecuteSoon.push_back(scriptLoader);
 
       postTask(BLINK_FROM_HERE);
 
       break;
 
     case InOrder:
       SECURITY_CHECK(m_numberOfInOrderScriptsWithPendingNotification > 0);
       m_numberOfInOrderScriptsWithPendingNotification--;
 
       scheduleReadyInOrderScripts();
@@ skipping 110 matching lines @@
 
 DEFINE_TRACE(ScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_pendingInOrderScripts);
   visitor->trace(m_pendingAsyncScripts);
   visitor->trace(m_asyncScriptsToExecuteSoon);
   visitor->trace(m_inOrderScriptsToExecuteSoon);
 }
 
 }  // namespace blink