Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/extension_throttle_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 <stddef.h>
 
 #include <cmath>
 #include <limits>
+#include <memory>
 #include <vector>
 
 #include "base/environment.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
 #include "extensions/browser/extension_throttle_manager.h"
 #include "extensions/browser/extension_throttle_test_support.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 "testing/gtest/include/gtest/gtest.h"
@@ skipping 13 matching lines @@
 const char kShowSimulationVariableName[] = "SHOW_SIMULATION_RESULTS";
 
 // Prints output only if a given environment variable is set. We use this
 // to not print any output for human evaluation when the test is run without
 // supervision.
 void VerboseOut(const char* format, ...) {
   static bool have_checked_environment = false;
   static bool should_print = false;
   if (!have_checked_environment) {
     have_checked_environment = true;
-    scoped_ptr<base::Environment> env(base::Environment::Create());
+    std::unique_ptr<base::Environment> env(base::Environment::Create());
     if (env->HasVar(kShowSimulationVariableName))
       should_print = true;
   }
 
   if (should_print) {
     va_list arglist;
     va_start(arglist, format);
     vprintf(format, arglist);
     va_end(arglist);
   }
@@ skipping 147 matching lines @@
     double ticks_per_column_exact =
         static_cast<double>(num_ticks) / static_cast<double>(terminal_width);
     int ticks_per_column = std::ceil(ticks_per_column_exact);
     DCHECK_GE(ticks_per_column * terminal_width, num_ticks);
 
     // Sum up the column values.
     int num_columns = num_ticks / ticks_per_column;
     if (num_ticks % ticks_per_column)
       ++num_columns;
     DCHECK_LE(num_columns, terminal_width);
-    scoped_ptr<int[]> columns(new int[num_columns]);
+    std::unique_ptr<int[]> columns(new int[num_columns]);
     for (int tx = 0; tx < num_ticks; ++tx) {
       int cx = tx / ticks_per_column;
       if (tx % ticks_per_column == 0)
         columns[cx] = 0;
       columns[cx] += requests_per_tick_[tx];
     }
 
     // Find the lowest integer divisor that will let the column values
     // be represented in a graph of maximum height 50.
     int max_value = 0;
@@ skipping 50 matching lines @@
   TimeTicks end_downtime_;
   const int max_queries_per_tick_;
   const double request_drop_ratio_;  // Ratio of requests to 503 when failing.
   int num_overloaded_ticks_remaining_;
   int num_current_tick_queries_;
   int num_overloaded_ticks_;
   int max_experienced_queries_per_tick_;
   std::vector<int> requests_per_tick_;
 
   TestURLRequestContext context_;
-  scoped_ptr<URLRequest> mock_request_;
+  std::unique_ptr<URLRequest> mock_request_;
 
   DISALLOW_COPY_AND_ASSIGN(Server);
 };
 
 // Mock throttler entry used by Requester class.
 class MockExtensionThrottleEntry : public ExtensionThrottleEntry {
  public:
   explicit MockExtensionThrottleEntry(ExtensionThrottleManager* manager)
       : ExtensionThrottleEntry(manager, std::string()),
         backoff_entry_(&backoff_policy_, &fake_clock_) {}
@@ skipping 175 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;
   ExtensionThrottleManager manager;
-  std::vector<scoped_ptr<Requester>> requesters;
+  std::vector<std::unique_ptr<Requester>> requesters;
   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<MockExtensionThrottleEntry> throttler_entry(
         new MockExtensionThrottleEntry(&manager));
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
     Requester* attacker =
         new Requester(throttler_entry.get(), TimeDelta::FromMilliseconds(1),
                       server, attacker_results);
     attacker->SetStartupJitter(TimeDelta::FromSeconds(120));
-    requesters.push_back(make_scoped_ptr(attacker));
+    requesters.push_back(base::WrapUnique(attacker));
     simulation.AddActor(attacker);
   }
   for (size_t i = 0; i < kNumClients; ++i) {
     // Normal clients only make requests every 2 minutes, plus/minus 1 minute.
     scoped_refptr<MockExtensionThrottleEntry> throttler_entry(
         new MockExtensionThrottleEntry(&manager));
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
     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(make_scoped_ptr(client));
+    requesters.push_back(base::WrapUnique(client));
     simulation.AddActor(client);
   }
   simulation.AddActor(server);
 
   simulation.RunSimulation(TimeDelta::FromMinutes(6),
                            TimeDelta::FromSeconds(1));
 }
 
 TEST(URLRequestThrottlerSimulation, HelpsInAttack) {
   base::MessageLoopForIO message_loop;
@@ skipping 205 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 extensions