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

chrome/browser/extensions/extension_request_limiting_throttle_browsertest.cc

 // Copyright 2015 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 <memory>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "extensions/browser/extension_throttle_manager.h"
 #include "extensions/test/result_catcher.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/url_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 
 namespace extensions {
 
 namespace {
 
-scoped_ptr<net::test_server::HttpResponse> HandleRequest(
+std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
     bool set_cache_header_redirect_page,
     bool set_cache_header_test_throttle_page,
     const net::test_server::HttpRequest& request) {
   if (base::StartsWith(request.relative_url, "/redirect",
                        base::CompareCase::SENSITIVE)) {
-    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_code(net::HTTP_FOUND);
     http_response->set_content("Redirecting...");
     http_response->set_content_type("text/plain");
     http_response->AddCustomHeader("Location", "/test_throttle");
     if (set_cache_header_redirect_page)
       http_response->AddCustomHeader("Cache-Control", "max-age=3600");
     return std::move(http_response);
   }
 
   if (base::StartsWith(request.relative_url, "/test_throttle",
                        base::CompareCase::SENSITIVE)) {
-    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_code(net::HTTP_SERVICE_UNAVAILABLE);
     http_response->set_content("The server is overloaded right now.");
     http_response->set_content_type("text/plain");
     if (set_cache_header_test_throttle_page)
       http_response->AddCustomHeader("Cache-Control", "max-age=3600");
     return std::move(http_response);
   }
 
   // Unhandled requests result in the Embedded test server sending a 404.
-  return scoped_ptr<net::test_server::BasicHttpResponse>();
+  return std::unique_ptr<net::test_server::BasicHttpResponse>();
 }
 
 }  // namespace
 
 class ExtensionRequestLimitingThrottleBrowserTest
     : public ExtensionBrowserTest {
  public:
   void SetUpOnMainThread() override {
     ExtensionBrowserTest::SetUpOnMainThread();
     ProfileIOData* io_data =
         ProfileIOData::FromResourceContext(profile()->GetResourceContext());
     ExtensionThrottleManager* manager = io_data->GetExtensionThrottleManager();
     if (manager) {
       // Requests issued within within |kUserGestureWindowMs| of a user gesture
       // are also considered as user gestures (see
       // resource_dispatcher_host_impl.cc), so these tests need to bypass the
       // checking of the net::LOAD_MAYBE_USER_GESTURE load flag in the manager
       // in order to test the throttling logic.
       manager->SetIgnoreUserGestureLoadFlagForTests(true);
-      scoped_ptr<
-          net::BackoffEntry::Policy> policy(new net::BackoffEntry::Policy{
-          // Number of initial errors (in sequence) to ignore before applying
-          // exponential back-off rules.
-          1,
+      std::unique_ptr<net::BackoffEntry::Policy> policy(
+          new net::BackoffEntry::Policy{
+              // Number of initial errors (in sequence) to ignore before
+              // applying
+              // exponential back-off rules.
+              1,
 
-          // Initial delay for exponential back-off in ms.
-          10 * 60 * 1000,
+              // Initial delay for exponential back-off in ms.
+              10 * 60 * 1000,
 
-          // Factor by which the waiting time will be multiplied.
-          10,
+              // Factor by which the waiting time will be multiplied.
+              10,
 
-          // Fuzzing percentage. ex: 10% will spread requests randomly
-          // between 90%-100% of the calculated time.
-          0.1,
+              // Fuzzing percentage. ex: 10% will spread requests randomly
+              // between 90%-100% of the calculated time.
+              0.1,
 
-          // Maximum amount of time we are willing to delay our request in ms.
-          15 * 60 * 1000,
+              // Maximum amount of time we are willing to delay our request in
+              // ms.
+              15 * 60 * 1000,
 
-          // Time to keep an entry from being discarded even when it
-          // has no significant state, -1 to never discard.
-          -1,
+              // Time to keep an entry from being discarded even when it
+              // has no significant state, -1 to never discard.
+              -1,
 
-          // Don't use initial delay unless the last request was an error.
-          false,
-      });
+              // Don't use initial delay unless the last request was an error.
+              false,
+          });
       manager->SetBackoffPolicyForTests(std::move(policy));
     }
     // Requests to 127.0.0.1 bypass throttling, so set up a host resolver rule
     // to use a fake domain.
     host_resolver()->AddRule("www.example.com", "127.0.0.1");
     ASSERT_TRUE(embedded_test_server()->Start());
     extension_ =
         LoadExtension(test_data_dir_.AppendASCII("extension_throttle"));
     ASSERT_TRUE(extension_);
   }
@@ skipping 119 matching lines @@
                        ThrottleRequestDisabled) {
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&HandleRequest, false, false));
   ASSERT_NO_FATAL_FAILURE(
       RunTest("test_request_not_throttled.html",
               base::StringPrintf("http://www.example.com:%d/test_throttle",
                                  embedded_test_server()->port())));
 }
 
 }  // namespace extensions