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

chrome/browser/extensions/api/declarative_webrequest/webrequest_action_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.
 
 #include "extensions/browser/api/declarative_webrequest/webrequest_action.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_condition.h"
@@ skipping 12 matching lines @@
 using base::ListValue;
 using extension_test_util::LoadManifestUnchecked;
 using testing::HasSubstr;
 
 namespace extensions {
 
 namespace {
 
 const char kUnknownActionType[] = "unknownType";
 
-scoped_ptr<WebRequestActionSet> CreateSetOfActions(const char* json) {
-  scoped_ptr<base::Value> parsed_value(base::test::ParseJson(json));
+std::unique_ptr<WebRequestActionSet> CreateSetOfActions(const char* json) {
+  std::unique_ptr<base::Value> parsed_value(base::test::ParseJson(json));
   const base::ListValue* parsed_list;
   CHECK(parsed_value->GetAsList(&parsed_list));
 
   WebRequestActionSet::Values actions;
   for (base::ListValue::const_iterator it = parsed_list->begin();
        it != parsed_list->end();
        ++it) {
     const base::DictionaryValue* dict;
     CHECK((*it)->GetAsDictionary(&dict));
     actions.push_back(dict->CreateDeepCopy());
   }
 
   std::string error;
   bool bad_message = false;
 
-  scoped_ptr<WebRequestActionSet> action_set(
+  std::unique_ptr<WebRequestActionSet> action_set(
       WebRequestActionSet::Create(NULL, NULL, actions, &error, &bad_message));
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   CHECK(action_set);
   return action_set;
 }
 
 }  // namespace
 
 namespace keys = declarative_webrequest_constants;
@@ skipping 63 matching lines @@
                                     base::Time::Now(),
                                     false /*incognito_enabled*/,
                                     false /*notifications_disabled*/);
 }
 
 bool WebRequestActionWithThreadsTest::ActionWorksOnRequest(
     const char* url_string,
     const std::string& extension_id,
     const WebRequestActionSet* action_set,
     RequestStage stage) {
-  scoped_ptr<net::URLRequest> regular_request(context_.CreateRequest(
-      GURL(url_string), net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> regular_request(
+      context_.CreateRequest(GURL(url_string), net::DEFAULT_PRIORITY, NULL));
   std::list<LinkedPtrEventResponseDelta> deltas;
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(""));
   WebRequestData request_data(regular_request.get(), stage, headers.get());
   std::set<std::string> ignored_tags;
   WebRequestAction::ApplyInfo apply_info = { extension_info_map_.get(),
                                              request_data,
                                              false /*crosses_incognito*/,
                                              &deltas, &ignored_tags };
   action_set->Apply(extension_id, base::Time(), &apply_info);
   return (1u == deltas.size() || 0u < ignored_tags.size());
 }
 
 void WebRequestActionWithThreadsTest::CheckActionNeedsAllUrls(
     const char* action,
     RequestStage stage) {
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(action));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(action));
 
   // Although |extension_| has matching *.com host permission, |action|
   // is intentionally forbidden -- in Declarative WR, host permission
   // for less than all URLs are ignored (except in SendMessageToExtension).
   EXPECT_FALSE(ActionWorksOnRequest(
       "http://test.com", extension_->id(), action_set.get(), stage));
   // With the "<all_urls>" host permission they are allowed.
   EXPECT_TRUE(ActionWorksOnRequest(
       "http://test.com", extension_all_urls_->id(), action_set.get(), stage));
 
@@ skipping 39 matching lines @@
   result = WebRequestAction::Create(NULL, NULL, input, &error, &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_EQ(WebRequestAction::ACTION_CANCEL_REQUEST, result->type());
 }
 
 TEST(WebRequestActionTest, CreateActionSet) {
   std::string error;
   bool bad_message = false;
-  scoped_ptr<WebRequestActionSet> result;
+  std::unique_ptr<WebRequestActionSet> result;
 
   WebRequestActionSet::Values input;
 
   // Test empty input.
   error.clear();
   result = WebRequestActionSet::Create(NULL, NULL, input, &error, &bad_message);
   EXPECT_TRUE(error.empty()) << error;
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_TRUE(result->actions().empty());
@@ skipping 98 matching lines @@
       "}]";
   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 }
 
 TEST_F(WebRequestActionWithThreadsTest, PermissionsToSendMessageToExtension) {
   const char kAction[] =
       "[{"
       " \"instanceType\": \"declarativeWebRequest.SendMessageToExtension\","
       " \"message\": \"testtext\""
       "}]";
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 
   // For sending messages, specific host permissions actually matter.
   EXPECT_TRUE(ActionWorksOnRequest("http://test.com",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_BEFORE_REQUEST));
   // With the "<all_urls>" host permission they are allowed.
   EXPECT_TRUE(ActionWorksOnRequest("http://test.com",
                                    extension_all_urls_->id(),
                                    action_set.get(),
@@ skipping 64 matching lines @@
       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
       "}]";
   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 }
 
 TEST_F(WebRequestActionWithThreadsTest, PermissionsToCancel) {
   const char kAction[] =
       "[{"
       " \"instanceType\": \"declarativeWebRequest.CancelRequest\""
       "}]";
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 
   // Cancelling requests works without full host permissions.
   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_BEFORE_REQUEST));
 }
 
 TEST_F(WebRequestActionWithThreadsTest,
        PermissionsToRedirectToTransparentImage) {
   const char kAction[] =
       "[{"
       " \"instanceType\": \"declarativeWebRequest.RedirectToTransparentImage\""
       "}]";
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 
   // Redirecting to transparent images works without full host permissions.
   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_BEFORE_REQUEST));
   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_HEADERS_RECEIVED));
 }
 
 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRedirectToEmptyDocument) {
   const char kAction[] =
       "[{"
       " \"instanceType\": \"declarativeWebRequest.RedirectToEmptyDocument\""
       "}]";
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 
   // Redirecting to the empty document works without full host permissions.
   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_BEFORE_REQUEST));
   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_HEADERS_RECEIVED));
 }
 
 TEST_F(WebRequestActionWithThreadsTest, PermissionsToIgnore) {
   const char kAction[] =
       "[{"
       " \"instanceType\": \"declarativeWebRequest.IgnoreRules\","
       " \"lowerPriorityThan\": 123,"
       " \"hasTag\": \"some_tag\""
       "}]";
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 
   // Ignoring rules works without full host permissions.
   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
                                    extension_->id(),
                                    action_set.get(),
                                    ON_BEFORE_REQUEST));
 }
 
 TEST(WebRequestActionTest, GetName) {
   const char kActions[] =
@@ skipping 80 matching lines @@
     "declarativeWebRequest.AddResponseCookie",
     "declarativeWebRequest.EditRequestCookie",
     "declarativeWebRequest.EditResponseCookie",
     "declarativeWebRequest.RemoveRequestCookie",
     "declarativeWebRequest.RemoveResponseCookie",
     "declarativeWebRequest.CancelRequest",
     "declarativeWebRequest.RedirectToTransparentImage",
     "declarativeWebRequest.RedirectToEmptyDocument",
     "declarativeWebRequest.IgnoreRules",
   };
-  scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kActions));
+  std::unique_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kActions));
   ASSERT_EQ(arraysize(kExpectedNames), action_set->actions().size());
   size_t index = 0;
   for (WebRequestActionSet::Actions::const_iterator it =
            action_set->actions().begin();
        it != action_set->actions().end();
        ++it) {
     EXPECT_EQ(kExpectedNames[index], (*it)->GetName());
     ++index;
   }
 }
 
 }  // namespace extensions