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

chrome/browser/extensions/api/web_request/web_request_api_unittest.cc

Index: chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
diff --git a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
index 0b4d32b4949e99c3865e3f446903449ae5177ae9..101825babdaeb0500931ec322047c1b0f9d8b5b2 100644
--- a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
+++ b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
@@ -6,6 +6,7 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <queue>
 #include <tuple>
 
@@ -16,7 +17,7 @@
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ -218,8 +219,8 @@ class ExtensionWebRequestTest : public testing::Test {
   TestIPCSender ipc_sender_;
   scoped_refptr<EventRouterForwarder> event_router_;
   scoped_refptr<InfoMap> extension_info_map_;
-  scoped_ptr<ChromeNetworkDelegate> network_delegate_;
-  scoped_ptr<net::TestURLRequestContext> context_;
+  std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
+  std::unique_ptr<net::TestURLRequestContext> context_;
 };
 
 // Tests that we handle disagreements among extensions about responses to
@@ -243,13 +244,13 @@ TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) {
   net::URLRequestJobFactoryImpl job_factory;
   job_factory.SetProtocolHandler(
       url::kAboutScheme,
-      make_scoped_ptr(new about_handler::AboutProtocolHandler()));
+      base::WrapUnique(new about_handler::AboutProtocolHandler()));
   context_->set_job_factory(&job_factory);
 
   GURL redirect_url("about:redirected");
   GURL not_chosen_redirect_url("about:not_chosen");
 
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
       GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
   {
     // onBeforeRequest will be dispatched twice initially. The second response -
@@ -304,7 +305,7 @@ TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) {
   }
 
   // Now test the same thing but the extensions answer in reverse order.
-  scoped_ptr<net::URLRequest> request2(context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request2(context_->CreateRequest(
       GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
   {
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
@@ -378,8 +379,8 @@ TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceCancel) {
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
 
   // onBeforeRequest will be dispatched twice. The second response -
   // the redirect - would win, since it has a later |install_time|, but
@@ -446,8 +447,8 @@ TEST_F(ExtensionWebRequestTest, SimulateChancelWhileBlocked) {
       kEventName2 + "/1", filter, 0, 0, 0, ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
 
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
@@ -509,23 +510,23 @@ void ExtensionWebRequestTest::FireURLRequestWithData(
     const std::vector<char>& bytes_2) {
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   GURL request_url("http://www.example.com");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
   request->set_method(method);
   if (content_type != NULL) {
     request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
                                          content_type,
                                          true /* overwrite */);
   }
-  std::vector<scoped_ptr<net::UploadElementReader>> element_readers;
-  element_readers.push_back(make_scoped_ptr(
+  std::vector<std::unique_ptr<net::UploadElementReader>> element_readers;
+  element_readers.push_back(base::WrapUnique(
       new net::UploadBytesElementReader(&(bytes_1[0]), bytes_1.size())));
-  element_readers.push_back(make_scoped_ptr(new net::UploadFileElementReader(
+  element_readers.push_back(base::WrapUnique(new net::UploadFileElementReader(
       base::ThreadTaskRunnerHandle::Get().get(), base::FilePath(), 0, 0,
       base::Time())));
-  element_readers.push_back(make_scoped_ptr(
+  element_readers.push_back(base::WrapUnique(
       new net::UploadBytesElementReader(&(bytes_2[0]), bytes_2.size())));
-  request->set_upload(make_scoped_ptr(
+  request->set_upload(base::WrapUnique(
       new net::ElementsUploadDataStream(std::move(element_readers), 0)));
   ipc_sender_.PushTask(base::Bind(&base::DoNothing));
   request->Start();
@@ -586,7 +587,8 @@ TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) {
   // Contents of formData.
   const char kFormData[] =
       "{\"A\":[\"test text\"],\"B\":[\"\"],\"C\":[\"test password\"]}";
-  scoped_ptr<const base::Value> form_data = base::JSONReader::Read(kFormData);
+  std::unique_ptr<const base::Value> form_data =
+      base::JSONReader::Read(kFormData);
   ASSERT_TRUE(form_data.get() != NULL);
   ASSERT_TRUE(form_data->GetType() == base::Value::TYPE_DICTIONARY);
   // Contents of raw.
@@ -803,7 +805,7 @@ TEST_F(ExtensionWebRequestTest, NoAccessRequestBodyData) {
   const GURL request_url("http://www.example.com");
 
   for (size_t i = 0; i < arraysize(kMethods); ++i) {
-    scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+    std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
         request_url, net::DEFAULT_PRIORITY, &delegate_));
     request->set_method(kMethods[i]);
     ipc_sender_.PushTask(base::Bind(&base::DoNothing));
@@ -893,9 +895,9 @@ class ExtensionWebRequestHeaderModificationTest
   TestIPCSender ipc_sender_;
   scoped_refptr<EventRouterForwarder> event_router_;
   scoped_refptr<InfoMap> extension_info_map_;
-  scoped_ptr<ChromeNetworkDelegate> network_delegate_;
-  scoped_ptr<net::MockHostResolver> host_resolver_;
-  scoped_ptr<net::TestURLRequestContext> context_;
+  std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
+  std::unique_ptr<net::MockHostResolver> host_resolver_;
+  std::unique_ptr<net::TestURLRequestContext> context_;
 };
 
 TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) {
@@ -925,8 +927,8 @@ TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) {
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("http://doesnotexist/does_not_exist.html");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
 
   // Initialize headers available before extensions are notified of the
   // onBeforeSendHeaders event.
@@ -1269,7 +1271,8 @@ TEST(ExtensionWebRequestHelpersTest, TestStringToCharList) {
   unsigned char char_value[] = {'1', '2', '3', 0xFE, 0xD1};
   std::string string_value(reinterpret_cast<char *>(char_value), 5);
 
-  scoped_ptr<base::ListValue> converted_list(StringToCharList(string_value));
+  std::unique_ptr<base::ListValue> converted_list(
+      StringToCharList(string_value));
   EXPECT_TRUE(list_value.Equals(converted_list.get()));
 
   std::string converted_string;
@@ -1280,9 +1283,8 @@ TEST(ExtensionWebRequestHelpersTest, TestStringToCharList) {
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeRequestDelta) {
   const bool cancel = true;
   const GURL localhost("http://localhost");
-  scoped_ptr<EventResponseDelta> delta(
-      CalculateOnBeforeRequestDelta("extid", base::Time::Now(),
-          cancel, localhost));
+  std::unique_ptr<EventResponseDelta> delta(CalculateOnBeforeRequestDelta(
+      "extid", base::Time::Now(), cancel, localhost));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   EXPECT_EQ(localhost, delta->new_url);
@@ -1300,9 +1302,9 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) {
   new_headers_added.AddHeadersFromString("key1: value1\r\n"
                                          "key3: value3\r\n"
                                          "key2: value2\r\n");
-  scoped_ptr<EventResponseDelta> delta_added(
+  std::unique_ptr<EventResponseDelta> delta_added(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_added));
+                                        &old_headers, &new_headers_added));
   ASSERT_TRUE(delta_added.get());
   EXPECT_TRUE(delta_added->cancel);
   ASSERT_TRUE(delta_added->modified_request_headers.GetHeader("key3", &value));
@@ -1311,9 +1313,9 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) {
   // Test deleting a header.
   net::HttpRequestHeaders new_headers_deleted;
   new_headers_deleted.AddHeadersFromString("key1: value1\r\n");
-  scoped_ptr<EventResponseDelta> delta_deleted(
+  std::unique_ptr<EventResponseDelta> delta_deleted(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_deleted));
+                                        &old_headers, &new_headers_deleted));
   ASSERT_TRUE(delta_deleted.get());
   ASSERT_EQ(1u, delta_deleted->deleted_request_headers.size());
   ASSERT_EQ("key2", delta_deleted->deleted_request_headers.front());
@@ -1322,9 +1324,9 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) {
   net::HttpRequestHeaders new_headers_modified;
   new_headers_modified.AddHeadersFromString("key1: value1\r\n"
                                             "key2: value3\r\n");
-  scoped_ptr<EventResponseDelta> delta_modified(
+  std::unique_ptr<EventResponseDelta> delta_modified(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_modified));
+                                        &old_headers, &new_headers_modified));
   ASSERT_TRUE(delta_modified.get());
   EXPECT_TRUE(delta_modified->deleted_request_headers.empty());
   ASSERT_TRUE(
@@ -1338,9 +1340,9 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) {
   new_headers_modified2.AddHeadersFromString("key1: value1\r\n"
                                              "key2: value2\r\n"
                                              "key2: value3\r\n");
-  scoped_ptr<EventResponseDelta> delta_modified2(
+  std::unique_ptr<EventResponseDelta> delta_modified2(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_modified));
+                                        &old_headers, &new_headers_modified));
   ASSERT_TRUE(delta_modified2.get());
   EXPECT_TRUE(delta_modified2->deleted_request_headers.empty());
   ASSERT_TRUE(
@@ -1370,13 +1372,9 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) {
   new_headers.push_back(ResponseHeader("Key5", "Value5, end5"));  // Unchanged
   GURL effective_new_url;
 
-  scoped_ptr<EventResponseDelta> delta(
-      CalculateOnHeadersReceivedDelta("extid",
-                                      base::Time::Now(),
-                                      cancel,
-                                      effective_new_url,
-                                      base_headers.get(),
-                                      &new_headers));
+  std::unique_ptr<EventResponseDelta> delta(CalculateOnHeadersReceivedDelta(
+      "extid", base::Time::Now(), cancel, effective_new_url, base_headers.get(),
+      &new_headers));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   EXPECT_EQ(2u, delta->added_response_headers.size());
@@ -1396,12 +1394,11 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
 
   base::string16 username = base::ASCIIToUTF16("foo");
   base::string16 password = base::ASCIIToUTF16("bar");
-  scoped_ptr<net::AuthCredentials> credentials(
+  std::unique_ptr<net::AuthCredentials> credentials(
       new net::AuthCredentials(username, password));
 
-  scoped_ptr<EventResponseDelta> delta(
-      CalculateOnAuthRequiredDelta("extid", base::Time::Now(), cancel,
-          &credentials));
+  std::unique_ptr<EventResponseDelta> delta(CalculateOnAuthRequiredDelta(
+      "extid", base::Time::Now(), cancel, &credentials));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   ASSERT_TRUE(delta->auth_credentials.get());