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

third_party/WebKit/Source/modules/mediastream/MediaStream.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011, 2012 Ericsson AB. 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 33 matching lines @@
   return false;
 }
 
 static void processTrack(MediaStreamTrack* track,
                          MediaStreamTrackVector& trackVector) {
   if (track->ended())
     return;
 
   MediaStreamSource* source = track->component()->source();
   if (!containsSource(trackVector, source))
-    trackVector.append(track);
+    trackVector.push_back(track);
 }
 
 MediaStream* MediaStream::create(ExecutionContext* context) {
   MediaStreamTrackVector audioTracks;
   MediaStreamTrackVector videoTracks;
 
   return new MediaStream(context, audioTracks, videoTracks);
 }
 
 MediaStream* MediaStream::create(ExecutionContext* context,
@@ skipping 35 matching lines @@
       m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired),
       m_executionContext(context) {
   m_descriptor->setClient(this);
 
   size_t numberOfAudioTracks = m_descriptor->numberOfAudioComponents();
   m_audioTracks.reserveCapacity(numberOfAudioTracks);
   for (size_t i = 0; i < numberOfAudioTracks; i++) {
     MediaStreamTrack* newTrack =
         MediaStreamTrack::create(context, m_descriptor->audioComponent(i));
     newTrack->registerMediaStream(this);
-    m_audioTracks.append(newTrack);
+    m_audioTracks.push_back(newTrack);
   }
 
   size_t numberOfVideoTracks = m_descriptor->numberOfVideoComponents();
   m_videoTracks.reserveCapacity(numberOfVideoTracks);
   for (size_t i = 0; i < numberOfVideoTracks; i++) {
     MediaStreamTrack* newTrack =
         MediaStreamTrack::create(context, m_descriptor->videoComponent(i));
     newTrack->registerMediaStream(this);
-    m_videoTracks.append(newTrack);
+    m_videoTracks.push_back(newTrack);
   }
 
   if (emptyOrOnlyEndedTracks()) {
     m_descriptor->setActive(false);
   }
 }
 
 MediaStream::MediaStream(ExecutionContext* context,
                          const MediaStreamTrackVector& audioTracks,
                          const MediaStreamTrackVector& videoTracks)
     : m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired),
       m_executionContext(context) {
   MediaStreamComponentVector audioComponents;
   MediaStreamComponentVector videoComponents;
 
   MediaStreamTrackVector::const_iterator iter;
   for (iter = audioTracks.begin(); iter != audioTracks.end(); ++iter) {
     (*iter)->registerMediaStream(this);
-    audioComponents.append((*iter)->component());
+    audioComponents.push_back((*iter)->component());
   }
   for (iter = videoTracks.begin(); iter != videoTracks.end(); ++iter) {
     (*iter)->registerMediaStream(this);
-    videoComponents.append((*iter)->component());
+    videoComponents.push_back((*iter)->component());
   }
 
   m_descriptor =
       MediaStreamDescriptor::create(audioComponents, videoComponents);
   m_descriptor->setClient(this);
   MediaStreamCenter::instance().didCreateMediaStream(m_descriptor);
 
   m_audioTracks = audioTracks;
   m_videoTracks = videoTracks;
   if (emptyOrOnlyEndedTracks()) {
@@ skipping 17 matching lines @@
     if (!iter->get()->ended())
       return false;
   }
   return true;
 }
 
 MediaStreamTrackVector MediaStream::getTracks() {
   MediaStreamTrackVector tracks;
   for (MediaStreamTrackVector::iterator iter = m_audioTracks.begin();
        iter != m_audioTracks.end(); ++iter)
-    tracks.append(iter->get());
+    tracks.push_back(iter->get());
   for (MediaStreamTrackVector::iterator iter = m_videoTracks.begin();
        iter != m_videoTracks.end(); ++iter)
-    tracks.append(iter->get());
+    tracks.push_back(iter->get());
   return tracks;
 }
 
 void MediaStream::addTrack(MediaStreamTrack* track,
                            ExceptionState& exceptionState) {
   if (!track) {
     exceptionState.throwDOMException(
         TypeMismatchError, "The MediaStreamTrack provided is invalid.");
     return;
   }
 
   if (getTrackById(track->id()))
     return;
 
   switch (track->component()->source()->type()) {
     case MediaStreamSource::TypeAudio:
-      m_audioTracks.append(track);
+      m_audioTracks.push_back(track);
       break;
     case MediaStreamSource::TypeVideo:
-      m_videoTracks.append(track);
+      m_videoTracks.push_back(track);
       break;
   }
   track->registerMediaStream(this);
   m_descriptor->addComponent(track->component());
 
   if (!active() && !track->ended()) {
     m_descriptor->setActive(true);
     scheduleDispatchEvent(Event::create(EventTypeNames::active));
   }
 
@@ skipping 50 matching lines @@
       return iter->get();
   }
 
   return 0;
 }
 
 MediaStream* MediaStream::clone(ExecutionContext* context) {
   MediaStreamTrackVector tracks;
   for (MediaStreamTrackVector::iterator iter = m_audioTracks.begin();
        iter != m_audioTracks.end(); ++iter)
-    tracks.append((*iter)->clone(context));
+    tracks.push_back((*iter)->clone(context));
   for (MediaStreamTrackVector::iterator iter = m_videoTracks.begin();
        iter != m_videoTracks.end(); ++iter)
-    tracks.append((*iter)->clone(context));
+    tracks.push_back((*iter)->clone(context));
   return MediaStream::create(context, tracks);
 }
 
 void MediaStream::trackEnded() {
   for (MediaStreamTrackVector::iterator iter = m_audioTracks.begin();
        iter != m_audioTracks.end(); ++iter) {
     if (!(*iter)->ended())
       return;
   }
 
@@ skipping 35 matching lines @@
 
 void MediaStream::addRemoteTrack(MediaStreamComponent* component) {
   DCHECK(component);
   if (!m_executionContext || m_executionContext->isContextDestroyed())
     return;
 
   MediaStreamTrack* track =
       MediaStreamTrack::create(m_executionContext, component);
   switch (component->source()->type()) {
     case MediaStreamSource::TypeAudio:
-      m_audioTracks.append(track);
+      m_audioTracks.push_back(track);
       break;
     case MediaStreamSource::TypeVideo:
-      m_videoTracks.append(track);
+      m_videoTracks.push_back(track);
       break;
   }
   track->registerMediaStream(this);
   m_descriptor->addComponent(component);
 
   scheduleDispatchEvent(
       MediaStreamTrackEvent::create(EventTypeNames::addtrack, track));
 
   if (!active() && !track->ended()) {
     m_descriptor->setActive(true);
@@ skipping 34 matching lines @@
   scheduleDispatchEvent(
       MediaStreamTrackEvent::create(EventTypeNames::removetrack, track));
 
   if (active() && emptyOrOnlyEndedTracks()) {
     m_descriptor->setActive(false);
     scheduleDispatchEvent(Event::create(EventTypeNames::inactive));
   }
 }
 
 void MediaStream::scheduleDispatchEvent(Event* event) {
-  m_scheduledEvents.append(event);
+  m_scheduledEvents.push_back(event);
 
   if (!m_scheduledEventTimer.isActive())
     m_scheduledEventTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void MediaStream::scheduledEventTimerFired(TimerBase*) {
   if (!m_executionContext || m_executionContext->isContextDestroyed())
     return;
 
   HeapVector<Member<Event>> events;
@@ skipping 18 matching lines @@
   visitor->trace(m_executionContext);
   EventTargetWithInlineData::trace(visitor);
   MediaStreamDescriptorClient::trace(visitor);
 }
 
 MediaStream* toMediaStream(MediaStreamDescriptor* descriptor) {
   return static_cast<MediaStream*>(descriptor->client());
 }
 
 }  // namespace blink