Migrate WTF::Vector::append() to ::push_back() [part 8 of N]

third_party/WebKit/Source/core/inspector/ThreadDebugger.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/inspector/ThreadDebugger.h"
 
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8DOMTokenList.h"
@@ skipping 258 matching lines @@
   createFunctionPropertyWithData(
       context, object, "unmonitorEvents",
       ThreadDebugger::unmonitorEventsCallback, functionValue,
       "function unmonitorEvents(object, [types]) { [Command Line API] }");
 }
 
 static Vector<String> normalizeEventTypes(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   Vector<String> types;
   if (info.Length() > 1 && info[1]->IsString())
-    types.append(toCoreString(info[1].As<v8::String>()));
+    types.push_back(toCoreString(info[1].As<v8::String>()));
   if (info.Length() > 1 && info[1]->IsArray()) {
     v8::Local<v8::Array> typesArray = v8::Local<v8::Array>::Cast(info[1]);
     for (size_t i = 0; i < typesArray->Length(); ++i) {
       v8::Local<v8::Value> typeValue;
       if (!typesArray->Get(info.GetIsolate()->GetCurrentContext(), i)
                .ToLocal(&typeValue) ||
           !typeValue->IsString())
         continue;
-      types.append(toCoreString(v8::Local<v8::String>::Cast(typeValue)));
+      types.push_back(toCoreString(v8::Local<v8::String>::Cast(typeValue)));
     }
   }
   if (info.Length() == 1)
     types.appendVector(
         Vector<String>({"mouse",   "key",          "touch",
                         "pointer", "control",      "load",
                         "unload",  "abort",        "error",
                         "select",  "input",        "change",
                         "submit",  "reset",        "focus",
                         "blur",    "resize",       "scroll",
@@ skipping 15 matching lines @@
     else if (types[i] == "pointer")
       outputTypes.appendVector(Vector<String>(
           {"pointerover", "pointerout", "pointerenter", "pointerleave",
            "pointerdown", "pointerup", "pointermove", "pointercancel",
            "gotpointercapture", "lostpointercapture"}));
     else if (types[i] == "control")
       outputTypes.appendVector(
           Vector<String>({"resize", "scroll", "zoom", "focus", "blur", "select",
                           "input", "change", "submit", "reset"}));
     else
-      outputTypes.append(types[i]);
+      outputTypes.push_back(types[i]);
   }
   return outputTypes;
 }
 
 static EventTarget* firstArgumentAsEventTarget(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   if (info.Length() < 1)
     return nullptr;
   if (EventTarget* target =
           V8EventTarget::toImplWithTypeCheck(info.GetIsolate(), info[0]))
@@ skipping 114 matching lines @@
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "TimeStamp", TRACE_EVENT_SCOPE_THREAD, "data",
       InspectorTimeStampEvent::data(currentExecutionContext(isolate),
                                     toCoreString(title)));
 }
 
 void ThreadDebugger::startRepeatingTimer(
     double interval,
     V8InspectorClient::TimerCallback callback,
     void* data) {
-  m_timerData.append(data);
-  m_timerCallbacks.append(callback);
+  m_timerData.push_back(data);
+  m_timerCallbacks.push_back(callback);
 
   std::unique_ptr<Timer<ThreadDebugger>> timer = WTF::wrapUnique(
       new Timer<ThreadDebugger>(this, &ThreadDebugger::onTimer));
   Timer<ThreadDebugger>* timerPtr = timer.get();
-  m_timers.append(std::move(timer));
+  m_timers.push_back(std::move(timer));
   timerPtr->startRepeating(interval, BLINK_FROM_HERE);
 }
 
 void ThreadDebugger::cancelTimer(void* data) {
   for (size_t index = 0; index < m_timerData.size(); ++index) {
     if (m_timerData[index] == data) {
       m_timers[index]->stop();
       m_timerCallbacks.remove(index);
       m_timers.remove(index);
       m_timerData.remove(index);
       return;
     }
   }
 }
 
 void ThreadDebugger::onTimer(TimerBase* timer) {
   for (size_t index = 0; index < m_timers.size(); ++index) {
     if (m_timers[index].get() == timer) {
       m_timerCallbacks[index](m_timerData[index]);
       return;
     }
   }
 }
 
 }  // namespace blink