Remove ScopedVector from CreateSockets

net/url_request/url_request_throttler_simulation_unittest.cc

 // Copyright (c) 2012 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.
 
 // The tests in this file attempt to verify the following through simulation:
 // a) That a server experiencing overload will actually benefit from the
 //    anti-DDoS throttling logic, i.e. that its traffic spike will subside
 //    and be distributed over a longer period of time;
 // b) That "well-behaved" clients of a server under DDoS attack actually
 //    benefit from the anti-DDoS throttling logic; and
 // c) That the approximate increase in "perceived downtime" introduced by
 //    anti-DDoS throttling for various different actual downtimes is what
 //    we expect it to be.
 
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "base/environment.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "net/url_request/url_request_throttler_test_support.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 450 matching lines @@
 };
 
 void SimulateAttack(Server* server,
                     RequesterResults* attacker_results,
                     RequesterResults* client_results,
                     bool enable_throttling) {
   const size_t kNumAttackers = 50;
   const size_t kNumClients = 50;
   DiscreteTimeSimulation simulation;
   URLRequestThrottlerManager manager;
-  ScopedVector<Requester> requesters;
+  std::vector<scoped_ptr<Requester>> requesters;

[mmenke, 2015/11/24 17:39:33]

This change really doesn't seem to belong in this CL - fine with grouping
changes in related files, but mdns and this file doesn't seem to have anything
in common.

   for (size_t i = 0; i < kNumAttackers; ++i) {
     // Use a tiny time_between_requests so the attackers will ping the
     // server at every tick of the simulation.
     scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
         new MockURLRequestThrottlerEntry(&manager));
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
-      Requester* attacker = new Requester(throttler_entry.get(),
-                                        TimeDelta::FromMilliseconds(1),
-                                        server,
-                                        attacker_results);
+    scoped_ptr<Requester> attacker(new Requester(throttler_entry.get(),
+                                                 TimeDelta::FromMilliseconds(1),
+                                                 server, attacker_results));
     attacker->SetStartupJitter(TimeDelta::FromSeconds(120));
-    requesters.push_back(attacker);
-    simulation.AddActor(attacker);
+    simulation.AddActor(attacker.get());
+    requesters.push_back(std::move(attacker));
   }
   for (size_t i = 0; i < kNumClients; ++i) {
     // Normal clients only make requests every 2 minutes, plus/minus 1 minute.
     scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
         new MockURLRequestThrottlerEntry(&manager));
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
-    Requester* client = new Requester(throttler_entry.get(),
-                                      TimeDelta::FromMinutes(2),
-                                      server,
-                                      client_results);
+    scoped_ptr<Requester> client(new Requester(throttler_entry.get(),
+                                               TimeDelta::FromMinutes(2),
+                                               server, client_results));
     client->SetStartupJitter(TimeDelta::FromSeconds(120));
     client->SetRequestJitter(TimeDelta::FromMinutes(1));
-    requesters.push_back(client);
-    simulation.AddActor(client);
+    simulation.AddActor(client.get());
+    requesters.push_back(std::move(client));
   }
   simulation.AddActor(server);
 
   simulation.RunSimulation(TimeDelta::FromMinutes(6),
                            TimeDelta::FromSeconds(1));
 }
 
 TEST(URLRequestThrottlerSimulation, HelpsInAttack) {
   Server unprotected_server(30, 1.0);
   RequesterResults unprotected_attacker_results;
@@ skipping 206 matching lines @@
     trials[i].PrintTrialDescription();
     trials[i].stats.ReportTrialResult(increase_ratio);
   }
 
   VerboseOut("Average increase ratio was %.4f\n", average_increase_ratio);
   VerboseOut("Maximum increase ratio was %.4f\n", max_increase_ratio);
 }
 
 }  // namespace
 }  // namespace net