Remove ScopedVector from CreateSockets

chrome/utility/local_discovery/service_discovery_message_handler.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 "chrome/utility/local_discovery/service_discovery_message_handler.h"
 
 #include <algorithm>
+#include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "chrome/common/local_discovery/local_discovery_messages.h"
 #include "chrome/common/local_discovery/service_discovery_client_impl.h"
 #include "content/public/utility/utility_thread.h"
 #include "net/base/net_util.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/udp/datagram_server_socket.h"
 
 namespace local_discovery {
 
@@ skipping 44 matching lines @@
   uint32 interface_index;
 };
 
 // Returns list of sockets preallocated before.
 class PreCreatedMDnsSocketFactory : public net::MDnsSocketFactory {
  public:
   PreCreatedMDnsSocketFactory() {}
   ~PreCreatedMDnsSocketFactory() override {
     // Not empty if process exits too fast, before starting mDns code. If
     // happened, destructors may crash accessing destroyed global objects.
-    sockets_.weak_clear();
+    // TODO This sounds memory leak, check and do better if possible
+    for (scoped_ptr<net::DatagramServerSocket>& it : sockets_)
+      base::IgnoreResult(it.release());
+    sockets_.clear();
   }
 
   // net::MDnsSocketFactory implementation:
   void CreateSockets(
-      ScopedVector<net::DatagramServerSocket>* sockets) override {
+      std::vector<scoped_ptr<net::DatagramServerSocket>>* sockets) override {
     sockets->swap(sockets_);
     Reset();
   }
 
   void AddSocket(const SocketInfo& socket_info) {
     // Takes ownership of socket_info.socket;
     ScopedSocketFactory platform_factory(socket_info.socket);
     scoped_ptr<net::DatagramServerSocket> socket(
         net::CreateAndBindMDnsSocket(socket_info.address_family,
                                      socket_info.interface_index));
     if (socket) {
       socket->DetachFromThread();
-      sockets_.push_back(socket.release());
+      sockets_.push_back(std::move(socket));
     }
   }
 
   void Reset() {
     sockets_.clear();
   }
 
  private:
-  ScopedVector<net::DatagramServerSocket> sockets_;
+  std::vector<scoped_ptr<net::DatagramServerSocket>> sockets_;
 
   DISALLOW_COPY_AND_ASSIGN(PreCreatedMDnsSocketFactory);
 };
 
 base::LazyInstance<PreCreatedMDnsSocketFactory>
     g_local_discovery_socket_factory = LAZY_INSTANCE_INITIALIZER;
 
 #if defined(OS_WIN)
 
 void ClosePlatformSocket(net::SocketDescriptor socket) {
@@ skipping 357 matching lines @@
           id, success, address_ipv4, address_ipv6));
 }
 
 void ServiceDiscoveryMessageHandler::Send(IPC::Message* msg) {
   utility_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(&SendHostMessageOnUtilityThread,
                                             msg));
 }
 
 }  // namespace local_discovery