Remove ScopedVector from content/renderer/.

content/renderer/media/webrtc/media_stream_track_metrics.cc

 // Copyright 2014 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 "content/renderer/media/webrtc/media_stream_track_metrics.h"
 
 #include <inttypes.h>
 #include <set>
 #include <string>
 
@@ skipping 134 matching lines @@
   base::ThreadChecker thread_checker_;
 };
 
 namespace {
 
 // Used with std::find_if.
 struct ObserverFinder {
   ObserverFinder(MediaStreamTrackMetrics::StreamType stream_type,
                  MediaStreamInterface* stream)
       : stream_type(stream_type), stream_(stream) {}
-  bool operator()(MediaStreamTrackMetricsObserver* observer) {
+  bool operator()(
+      const std::unique_ptr<MediaStreamTrackMetricsObserver>& observer) {
     return stream_ == observer->stream() &&
            stream_type == observer->stream_type();
   }
   MediaStreamTrackMetrics::StreamType stream_type;
   MediaStreamInterface* stream_;
 };
 
 }  // namespace
 
 MediaStreamTrackMetricsObserver::MediaStreamTrackMetricsObserver(
@@ skipping 95 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   for (IdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
     owner_->SendLifetimeMessage(*it, track_type, event, stream_type_);
   }
 }
 
 MediaStreamTrackMetrics::MediaStreamTrackMetrics()
     : ice_state_(webrtc::PeerConnectionInterface::kIceConnectionNew) {}
 
 MediaStreamTrackMetrics::~MediaStreamTrackMetrics() {
-  for (ObserverVector::iterator it = observers_.begin(); it != observers_.end();
-       ++it) {
-    (*it)->SendLifetimeMessages(DISCONNECTED);
+  for (const auto& observer : observers_) {
+    observer->SendLifetimeMessages(DISCONNECTED);
   }
 }
 
 void MediaStreamTrackMetrics::AddStream(StreamType type,
                                         MediaStreamInterface* stream) {
   DCHECK(CalledOnValidThread());
-  MediaStreamTrackMetricsObserver* observer =
-      new MediaStreamTrackMetricsObserver(type, stream, this);
-  observers_.insert(observers_.end(), observer);
-  SendLifeTimeMessageDependingOnIceState(observer);
+  observers_.push_back(
+      base::MakeUnique<MediaStreamTrackMetricsObserver>(type, stream, this));
+  SendLifeTimeMessageDependingOnIceState(observers_.back().get());
 }
 
 void MediaStreamTrackMetrics::RemoveStream(StreamType type,
                                            MediaStreamInterface* stream) {
   DCHECK(CalledOnValidThread());
-  ObserverVector::iterator it = std::find_if(
-      observers_.begin(), observers_.end(), ObserverFinder(type, stream));
+  auto it = std::find_if(observers_.begin(), observers_.end(),
+                         ObserverFinder(type, stream));
   if (it == observers_.end()) {
     // Since external apps could call removeStream with a stream they
     // never added, this can happen without it being an error.
     return;
   }
 
   observers_.erase(it);
 }
 
 void MediaStreamTrackMetrics::IceConnectionChange(
     PeerConnectionInterface::IceConnectionState new_state) {
   DCHECK(CalledOnValidThread());
   ice_state_ = new_state;
-  for (ObserverVector::iterator it = observers_.begin(); it != observers_.end();
-       ++it) {
-    SendLifeTimeMessageDependingOnIceState(*it);
+  for (const auto& observer : observers_) {
+    SendLifeTimeMessageDependingOnIceState(observer.get());
   }
 }
 void MediaStreamTrackMetrics::SendLifeTimeMessageDependingOnIceState(
     MediaStreamTrackMetricsObserver* observer) {
   // There is a state transition diagram for these states at
   // http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCIceConnectionState
   switch (ice_state_) {
     case PeerConnectionInterface::kIceConnectionConnected:
     case PeerConnectionInterface::kIceConnectionCompleted:
       observer->SendLifetimeMessages(CONNECTED);
@@ skipping 77 matching lines @@
 }
 
 uint64_t MediaStreamTrackMetrics::MakeUniqueId(const std::string& track_id,
                                                StreamType stream_type) {
   return MakeUniqueIdImpl(
       reinterpret_cast<uint64_t>(reinterpret_cast<void*>(this)), track_id,
       stream_type);
 }
 
 }  // namespace content