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

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_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_rules_registry.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "components/url_matcher/url_matcher_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/browser/api/declarative/rules_registry_service.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
@@ skipping 155 matching lines @@
     linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId4));
     rule->priority.reset(new int(200));
     rule->actions.push_back(action_dict.CreateDeepCopy());
     rule->conditions.push_back(condition_dict.CreateDeepCopy());
     return rule;
   }
 
   // Create a condition with the attributes specified. An example value of
   // |attributes| is: "\"resourceType\": [\"stylesheet\"], \n".
-  scoped_ptr<base::Value> CreateCondition(const std::string& attributes) {
+  std::unique_ptr<base::Value> CreateCondition(const std::string& attributes) {
     std::string json_description =
         "{ \n"
         "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n";
     json_description += attributes;
     json_description += "}";
 
     return base::test::ParseJson(json_description);
   }
 
   // Create a rule with the ID |rule_id| and with conditions created from the
@@ skipping 69 matching lines @@
   rules.push_back(CreateRule2());
 
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<const WebRequestRule*> matches;
 
   GURL http_url("http://www.example.com");
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> http_request(context.CreateRequest(
-      http_url, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> http_request(
+      context.CreateRequest(http_url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(http_request.get(), ON_BEFORE_REQUEST);
   matches = registry->GetMatches(request_data);
   EXPECT_EQ(2u, matches.size());
 
   std::set<WebRequestRule::GlobalRuleId> matches_ids;
   for (std::set<const WebRequestRule*>::const_iterator it = matches.begin();
        it != matches.end(); ++it)
     matches_ids.insert((*it)->id());
   EXPECT_TRUE(ContainsKey(matches_ids, std::make_pair(kExtensionId, kRuleId1)));
   EXPECT_TRUE(ContainsKey(matches_ids, std::make_pair(kExtensionId, kRuleId2)));
 
   GURL foobar_url("http://www.foobar.com");
-  scoped_ptr<net::URLRequest> foobar_request(context.CreateRequest(
-      foobar_url, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> foobar_request(
+      context.CreateRequest(foobar_url, net::DEFAULT_PRIORITY, NULL));
   request_data.request = foobar_request.get();
   matches = registry->GetMatches(request_data);
   EXPECT_EQ(1u, matches.size());
   WebRequestRule::GlobalRuleId expected_pair =
       std::make_pair(kExtensionId, kRuleId2);
   EXPECT_EQ(expected_pair, (*matches.begin())->id());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveRulesImpl) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
@@ skipping 105 matching lines @@
   error = registry->AddRules(kExtensionId, rules_to_add_1);
   EXPECT_EQ("", error);
 
   std::vector<linked_ptr<api::events::Rule>> rules_to_add_2(1);
   rules_to_add_2[0] = CreateRedirectRule("http://www.bar.com");
   error = registry->AddRules(kExtensionId2, rules_to_add_2);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com");
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(context.CreateRequest(
-      url, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> request(
+      context.CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(NULL, request_data, false);
 
   // The second extension is installed later and will win for this reason
   // in conflict resolution.
   ASSERT_EQ(2u, deltas.size());
   deltas.sort(&helpers::InDecreasingExtensionInstallationTimeOrder);
 
   std::list<LinkedPtrEventResponseDelta>::iterator i = deltas.begin();
@@ skipping 27 matching lines @@
   error = registry->AddRules(kExtensionId2, rules_to_add_2);
   EXPECT_EQ("", error);
 
   std::vector<linked_ptr<api::events::Rule>> rules_to_add_3(1);
   rules_to_add_3[0] = CreateIgnoreRule();
   error = registry->AddRules(kExtensionId, rules_to_add_3);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com/index.html");
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(context.CreateRequest(
-      url, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> request(
+      context.CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(NULL, request_data, false);
 
   // The redirect by the first extension is ignored due to the ignore rule.
   ASSERT_EQ(1u, deltas.size());
   LinkedPtrEventResponseDelta effective_rule = *(deltas.begin());
 
   EXPECT_EQ(kExtensionId2, effective_rule->extension_id);
   EXPECT_EQ(base::Time() + base::TimeDelta::FromDays(2),
@@ skipping 33 matching lines @@
       "  ],                                                              \n"
       "  \"actions\": [                                                  \n"
       "    {                                                             \n"
       "      \"instanceType\": \"declarativeWebRequest.IgnoreRules\",    \n"
       "      \"hasTag\": \"ignore_tag\"                                  \n"
       "    }                                                             \n"
       "  ],                                                              \n"
       "  \"priority\": 300                                               \n"
       "}                                                                 ";
 
-  scoped_ptr<base::Value> value1 = base::JSONReader::Read(kRule1);
+  std::unique_ptr<base::Value> value1 = base::JSONReader::Read(kRule1);
   ASSERT_TRUE(value1.get());
-  scoped_ptr<base::Value> value2 = base::JSONReader::Read(kRule2);
+  std::unique_ptr<base::Value> value2 = base::JSONReader::Read(kRule2);
   ASSERT_TRUE(value2.get());
 
   std::vector<linked_ptr<api::events::Rule>> rules;
   rules.push_back(make_linked_ptr(new api::events::Rule));
   rules.push_back(make_linked_ptr(new api::events::Rule));
   ASSERT_TRUE(api::events::Rule::Populate(*value1, rules[0].get()));
   ASSERT_TRUE(api::events::Rule::Populate(*value2, rules[1].get()));
 
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error = registry->AddRulesImpl(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_FALSE(registry->IsEmpty());
 
   GURL url("http://www.foo.com/test");
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(context.CreateRequest(
-      url, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> request(
+      context.CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(NULL, request_data, false);
 
   // The redirect by the redirect rule is ignored due to the ignore rule.
   std::set<const WebRequestRule*> matches = registry->GetMatches(request_data);
   EXPECT_EQ(2u, matches.size());
   ASSERT_EQ(0u, deltas.size());
 }
 
@@ skipping 28 matching lines @@
   rules.push_back(CreateCancellingRule(kRuleId3, attributes));
 
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<const WebRequestRule*> matches;
 
   GURL http_url("http://www.example.com");
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> http_request(context.CreateRequest(
-      http_url, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> http_request(
+      context.CreateRequest(http_url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(http_request.get(), ON_BEFORE_REQUEST);
   matches = registry->GetMatches(request_data);
   EXPECT_EQ(1u, matches.size());
   WebRequestRule::GlobalRuleId expected_pair = std::make_pair(kExtensionId,
                                                               kRuleId3);
   EXPECT_EQ(expected_pair, (*matches.begin())->id());
 }
 
 // Test that the url and firstPartyForCookiesUrl attributes are evaluated
 // against corresponding URLs. Tested on requests where these URLs actually
@@ skipping 37 matching lines @@
   static_assert(arraysize(urls) == arraysize(firstPartyUrls),
                 "urls and firstPartyUrls must have the same number "
                 "of elements");
   static_assert(arraysize(urls) == arraysize(matchingRuleIds),
                 "urls and matchingRuleIds must have the same number "
                 "of elements");
   net::TestURLRequestContext context;
 
   for (size_t i = 0; i < arraysize(matchingRuleIds); ++i) {
     // Construct the inputs.
-    scoped_ptr<net::URLRequest> http_request(context.CreateRequest(
-        urls[i], net::DEFAULT_PRIORITY, NULL));
+    std::unique_ptr<net::URLRequest> http_request(
+        context.CreateRequest(urls[i], net::DEFAULT_PRIORITY, NULL));
     WebRequestData request_data(http_request.get(), ON_BEFORE_REQUEST);
     http_request->set_first_party_for_cookies(firstPartyUrls[i]);
     // Now run both rules on the input.
     matches = registry->GetMatches(request_data);
     SCOPED_TRACE(testing::Message("i = ") << i << ", rule id = "
                                           << matchingRuleIds[i]);
     // Make sure that the right rule succeeded.
     EXPECT_EQ(1u, matches.size());
     EXPECT_EQ(WebRequestRule::GlobalRuleId(std::make_pair(kExtensionId,
                                                           matchingRuleIds[i])),
@@ skipping 19 matching lines @@
       "  \"actions\": [                                                   \n"
       "    {                                                              \n"
       "      \"instanceType\": \"declarativeWebRequest.SetRequestHeader\",\n"
       "      \"name\": \"Content-Type\",                                  \n"
       "      \"value\": \"text/plain\"                                    \n"
       "    }                                                              \n"
       "  ],                                                               \n"
       "  \"priority\": 200                                                \n"
       "}                                                                  ";
 
-  scoped_ptr<base::Value> value = base::JSONReader::Read(kRule);
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(kRule);
   ASSERT_TRUE(value);
 
   api::events::Rule rule;
   ASSERT_TRUE(api::events::Rule::Populate(*value, &rule));
 
   std::string error;
   URLMatcher matcher;
-  scoped_ptr<WebRequestConditionSet> conditions =
-      WebRequestConditionSet::Create(
-          NULL, matcher.condition_factory(), rule.conditions, &error);
+  std::unique_ptr<WebRequestConditionSet> conditions =
+      WebRequestConditionSet::Create(NULL, matcher.condition_factory(),
+                                     rule.conditions, &error);
   ASSERT_TRUE(error.empty()) << error;
   ASSERT_TRUE(conditions);
 
   bool bad_message = false;
-  scoped_ptr<WebRequestActionSet> actions =
-      WebRequestActionSet::Create(
-          NULL, NULL, rule.actions, &error, &bad_message);
+  std::unique_ptr<WebRequestActionSet> actions = WebRequestActionSet::Create(
+      NULL, NULL, rule.actions, &error, &bad_message);
   ASSERT_TRUE(error.empty()) << error;
   ASSERT_FALSE(bad_message);
   ASSERT_TRUE(actions);
 
   EXPECT_FALSE(WebRequestRulesRegistry::StageChecker(
       conditions.get(), actions.get(), &error));
   EXPECT_THAT(error, HasSubstr("no time in the request life-cycle"));
   EXPECT_THAT(error, HasSubstr(actions->actions().back()->GetName()));
 }
 
 TEST(WebRequestRulesRegistrySimpleTest, HostPermissionsChecker) {
   const char kAction[] =  // This action requires all URLs host permission.
       "{                                                             \n"
       "  \"instanceType\": \"declarativeWebRequest.RedirectRequest\",\n"
       "  \"redirectUrl\": \"http://bar.com\"                         \n"
       "}                                                             ";
-  scoped_ptr<base::Value> action_value = base::JSONReader::Read(kAction);
+  std::unique_ptr<base::Value> action_value = base::JSONReader::Read(kAction);
   ASSERT_TRUE(action_value);
 
   WebRequestActionSet::Values actions;
   actions.push_back(std::move(action_value));
   ASSERT_TRUE(actions.back().get());
 
   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));
   ASSERT_TRUE(error.empty()) << error;
   ASSERT_FALSE(bad_message);
   ASSERT_TRUE(action_set);
 
   scoped_refptr<Extension> extension_no_url(
       LoadManifest("permissions", "web_request_no_host.json"));
   scoped_refptr<Extension> extension_some_urls(
       LoadManifest("permissions", "web_request_com_host_permissions.json"));
   scoped_refptr<Extension> extension_all_urls(
@@ skipping 26 matching lines @@
       "  ],                                                              \n"
       "  \"actions\": [                                                  \n"
       "    {                                                             \n"
       "      \"instanceType\": \"declarativeWebRequest.RedirectRequest\",\n"
       "      \"redirectUrl\": \"http://bar.com\"                         \n"
       "    }                                                             \n"
       "  ],                                                              \n"
       "  \"priority\": 200                                               \n"
       "}                                                                 ";
 
-  scoped_ptr<base::Value> value = base::JSONReader::Read(kRule);
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(kRule);
   ASSERT_TRUE(value.get());
 
   std::vector<linked_ptr<api::events::Rule>> rules;
   rules.push_back(make_linked_ptr(new api::events::Rule));
   ASSERT_TRUE(api::events::Rule::Populate(*value, rules.back().get()));
 
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
 
   URLMatcher matcher;
   std::string error = registry->AddRulesImpl(kExtensionId, rules);
   EXPECT_EQ("", error);
 
   net::TestURLRequestContext context;
   std::list<LinkedPtrEventResponseDelta> deltas;
 
   // No match because match is in the query parameter.
   GURL url1("http://bar.com/index.html?foo.com");
-  scoped_ptr<net::URLRequest> request1(context.CreateRequest(
-      url1, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> request1(
+      context.CreateRequest(url1, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data1(request1.get(), ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data1, false);
   EXPECT_EQ(0u, deltas.size());
 
   // This is a correct match.
   GURL url2("http://foo.com/index.html");
-  scoped_ptr<net::URLRequest> request2(context.CreateRequest(
-      url2, net::DEFAULT_PRIORITY, NULL));
+  std::unique_ptr<net::URLRequest> request2(
+      context.CreateRequest(url2, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data2(request2.get(), ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data2, false);
   EXPECT_EQ(1u, deltas.size());
 }
 
 }  // namespace extensions