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

third_party/WebKit/Source/modules/peerconnection/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 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
@@ skipping 261 matching lines @@
   webConfiguration.rtcpMuxPolicy = rtcpMuxPolicy;
 
   if (configuration.hasIceServers()) {
     Vector<WebRTCIceServer> iceServers;
     for (const RTCIceServer& iceServer : configuration.iceServers()) {
       Vector<String> urlStrings;
       if (iceServer.hasURLs()) {
         UseCounter::count(context, UseCounter::RTCIceServerURLs);
         const StringOrStringSequence& urls = iceServer.urls();
         if (urls.isString()) {
-          urlStrings.append(urls.getAsString());
+          urlStrings.push_back(urls.getAsString());
         } else {
           DCHECK(urls.isStringSequence());
           urlStrings = urls.getAsStringSequence();
         }
       } else if (iceServer.hasURL()) {
         UseCounter::count(context, UseCounter::RTCIceServerURL);
-        urlStrings.append(iceServer.url());
+        urlStrings.push_back(iceServer.url());
       } else {
         exceptionState.throwTypeError("Malformed RTCIceServer");
         return WebRTCConfiguration();
       }
 
       String username = iceServer.username();
       String credential = iceServer.credential();
 
       for (const String& urlString : urlStrings) {
         KURL url(KURL(), urlString);
@@ skipping 10 matching lines @@
                                "'stun', 'turn' or 'turns'.");
           return WebRTCConfiguration();
         }
         if ((url.protocolIs("turn") || url.protocolIs("turns")) &&
             (username.isNull() || credential.isNull())) {
           exceptionState.throwDOMException(InvalidAccessError,
                                            "Both username and credential are "
                                            "required when the URL scheme is "
                                            "\"turn\" or \"turns\".");
         }
-        iceServers.append(WebRTCIceServer{url, username, credential});
+        iceServers.push_back(WebRTCIceServer{url, username, credential});
       }
     }
     webConfiguration.iceServers = iceServers;
   }
 
   if (configuration.hasCertificates()) {
     const HeapVector<Member<RTCCertificate>>& certificates =
         configuration.certificates();
     WebVector<std::unique_ptr<WebRTCCertificate>> certificatesCopy(
         certificates.size());
@@ skipping 738 matching lines @@
     return;
 
   MediaErrorState mediaErrorState;
   WebMediaConstraints constraints =
       MediaConstraintsImpl::create(context, mediaConstraints, mediaErrorState);
   if (mediaErrorState.hadException()) {
     mediaErrorState.raiseException(exceptionState);
     return;
   }
 
-  m_localStreams.append(stream);
+  m_localStreams.push_back(stream);
 
   bool valid = m_peerHandler->addStream(stream->descriptor(), constraints);
   if (!valid)
     exceptionState.throwDOMException(SyntaxError,
                                      "Unable to add the provided stream.");
 }
 
 void RTCPeerConnection::removeStream(MediaStream* stream,
                                      ExceptionState& exceptionState) {
   if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
@@ skipping 190 matching lines @@
 
 void RTCPeerConnection::didAddRemoteStream(const WebMediaStream& remoteStream) {
   DCHECK(!m_closed);
   DCHECK(getExecutionContext()->isContextThread());
 
   if (m_signalingState == SignalingStateClosed)
     return;
 
   MediaStream* stream =
       MediaStream::create(getExecutionContext(), remoteStream);
-  m_remoteStreams.append(stream);
+  m_remoteStreams.push_back(stream);
 
   scheduleDispatchEvent(
       MediaStreamEvent::create(EventTypeNames::addstream, stream));
 }
 
 void RTCPeerConnection::didRemoveRemoteStream(
     const WebMediaStream& remoteStream) {
   DCHECK(!m_closed);
   DCHECK(getExecutionContext()->isContextThread());
 
@@ skipping 113 matching lines @@
   changeSignalingState(SignalingStateClosed);
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(Event* event) {
   scheduleDispatchEvent(event, nullptr);
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(
     Event* event,
     std::unique_ptr<BoolFunction> setupFunction) {
-  m_scheduledEvents.append(new EventWrapper(event, std::move(setupFunction)));
+  m_scheduledEvents.push_back(
+      new EventWrapper(event, std::move(setupFunction)));
 
   m_dispatchScheduledEventRunner->runAsync();
 }
 
 void RTCPeerConnection::dispatchScheduledEvent() {
   if (m_stopped)
     return;
 
   HeapVector<Member<EventWrapper>> events;
   events.swap(m_scheduledEvents);
@@ skipping 36 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink