Remove ScopedVector from CreateSockets

net/dns/mdns_client_unittest.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 <queue>
 
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/timer/mock_timer.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mdns_client_impl.h"
 #include "net/dns/mock_mdns_socket_factory.h"
@@ skipping 1131 matching lines @@
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _));
 
   RunFor(base::TimeDelta::FromSeconds(6));
 }
 
 // Note: These tests assume that the ipv4 socket will always be created first.
 // This is a simplifying assumption based on the way the code works now.
 class SimpleMockSocketFactory : public MDnsSocketFactory {
  public:
-  void CreateSockets(ScopedVector<DatagramServerSocket>* sockets) override {
+  void CreateSockets(
+      std::vector<scoped_ptr<DatagramServerSocket>>* sockets) override {

[mmenke, 2015/11/30 20:36:45]

include <vector>

     sockets->clear();
     sockets->swap(sockets_);
   }
 
-  void PushSocket(DatagramServerSocket* socket) {
-    sockets_.push_back(socket);
+  void PushSocket(scoped_ptr<DatagramServerSocket> socket) {
+    sockets_.push_back(std::move(socket));
   }
 
  private:
-  ScopedVector<DatagramServerSocket> sockets_;
+  std::vector<scoped_ptr<DatagramServerSocket>> sockets_;
 };
 
 class MockMDnsConnectionDelegate : public MDnsConnection::Delegate {
  public:
   virtual void HandlePacket(DnsResponse* response, int size) {
     HandlePacketInternal(std::string(response->io_buffer()->data(), size));
   }
 
   MOCK_METHOD1(HandlePacketInternal, void(std::string packet));
 
   MOCK_METHOD1(OnConnectionError, void(int error));
 };
 
 class MDnsConnectionTest : public ::testing::Test {
  public:
   MDnsConnectionTest() : connection_(&delegate_) {
   }
 
  protected:
   // Follow successful connection initialization.
   void SetUp() override {
     socket_ipv4_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV4);
     socket_ipv6_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV6);
-    factory_.PushSocket(socket_ipv6_);
-    factory_.PushSocket(socket_ipv4_);
+    factory_.PushSocket(make_scoped_ptr(socket_ipv6_));
+    factory_.PushSocket(make_scoped_ptr(socket_ipv4_));
     sample_packet_ = MakeString(kSamplePacket1, sizeof(kSamplePacket1));
     sample_buffer_ = new StringIOBuffer(sample_packet_);
   }
 
   bool InitConnection() {
     return connection_.Init(&factory_);
   }
 
   StrictMock<MockMDnsConnectionDelegate> delegate_;
 
@@ skipping 108 matching lines @@
               SendToInternal(sample_packet_, "224.0.0.251:5353", _))
       .Times(0);
   // Expect call for the second IPv6 packed.
   EXPECT_CALL(*socket_ipv6_,
               SendToInternal(sample_packet_, "[ff02::fb]:5353", _))
       .WillOnce(Return(OK));
   callback.Run(OK);
 }
 
 }  // namespace net