Remove ScopedVector from CreateSockets

net/dns/mdns_client_impl.cc

 // Copyright 2013 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 "net/dns/mdns_client_impl.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 // The fractions of the record's original TTL after which an active listener
 // (one that had |SetActiveRefresh(true)| called) will send a query to refresh
 // its cache. This happens both at 85% of the original TTL and again at 95% of
 // the original TTL.
 const double kListenerRefreshRatio1 = 0.85;
 const double kListenerRefreshRatio2 = 0.95;
 
 }  // namespace
 
 void MDnsSocketFactoryImpl::CreateSockets(
-    ScopedVector<DatagramServerSocket>* sockets) {
+    std::vector<scoped_ptr<DatagramServerSocket>>* sockets) {
   InterfaceIndexFamilyList interfaces(GetMDnsInterfacesToBind());
   for (size_t i = 0; i < interfaces.size(); ++i) {
     DCHECK(interfaces[i].second == ADDRESS_FAMILY_IPV4 ||
            interfaces[i].second == ADDRESS_FAMILY_IPV6);
     scoped_ptr<DatagramServerSocket> socket(
         CreateAndBindMDnsSocket(interfaces[i].second, interfaces[i].first));
     if (socket)
       sockets->push_back(socket.Pass());
   }
 }
@@ skipping 77 matching lines @@
 }
 
 MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate)
     : delegate_(delegate), weak_ptr_factory_(this) {
 }
 
 MDnsConnection::~MDnsConnection() {
 }
 
 bool MDnsConnection::Init(MDnsSocketFactory* socket_factory) {
-  ScopedVector<DatagramServerSocket> sockets;
+  std::vector<scoped_ptr<DatagramServerSocket>> sockets;
   socket_factory->CreateSockets(&sockets);
 
-  for (size_t i = 0; i < sockets.size(); ++i) {
-    socket_handlers_.push_back(
-        new MDnsConnection::SocketHandler(make_scoped_ptr(sockets[i]), this));
+  for (scoped_ptr<DatagramServerSocket>& socket : sockets) {
+    socket_handlers_.push_back(make_scoped_ptr(
+        new MDnsConnection::SocketHandler(std::move(socket), this)));
   }
-  sockets.weak_clear();
 
   // All unbound sockets need to be bound before processing untrusted input.
   // This is done for security reasons, so that an attacker can't get an unbound
   // socket.
   for (size_t i = 0; i < socket_handlers_.size();) {
     int rv = socket_handlers_[i]->Start();
     if (rv != OK) {
       socket_handlers_.erase(socket_handlers_.begin() + i);
       VLOG(1) << "Start failed, socket=" << i << ", error=" << rv;
     } else {
       ++i;
     }
   }
   VLOG(1) << "Sockets ready:" << socket_handlers_.size();
   return !socket_handlers_.empty();
 }
 
 void MDnsConnection::Send(const scoped_refptr<IOBuffer>& buffer,
                           unsigned size) {
-  for (size_t i = 0; i < socket_handlers_.size(); ++i)
-    socket_handlers_[i]->Send(buffer, size);
+  for (scoped_ptr<SocketHandler>& handler : socket_handlers_)
+    handler->Send(buffer, size);
 }
 
 void MDnsConnection::PostOnError(SocketHandler* loop, int rv) {
-  VLOG(1) << "Socket error. id="
-          << std::find(socket_handlers_.begin(), socket_handlers_.end(), loop) -
-                 socket_handlers_.begin() << ", error=" << rv;
+  int id = 0;
+  for (const auto& it : socket_handlers_) {
+    if (it.get() == loop)
+      break;
+    id++;
+  }
+  VLOG(1) << "Socket error. id=" << id << ", error=" << rv;
   // Post to allow deletion of this object by delegate.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&MDnsConnection::OnError, weak_ptr_factory_.GetWeakPtr(), rv));
 }
 
 void MDnsConnection::OnError(int rv) {
   // TODO(noamsml): Specific handling of intermittent errors that can be handled
   // in the connection.
   delegate_->OnConnectionError(rv);
@@ skipping 551 matching lines @@
 
 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
   TriggerCallback(RESULT_NSEC, NULL);
 }
 
 void MDnsTransactionImpl::OnCachePurged() {
   // TODO(noamsml): Cache purge situations not yet implemented
 }
 
 }  // namespace net