Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/url_matcher/url_matcher_unittest.cc

 // Copyright 2013 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 "components/url_matcher/url_matcher.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace url_matcher {
 
 //
@@ skipping 455 matching lines @@
   std::set<StringPattern::ID> matching_patterns;
   matching_patterns.insert(m1.string_pattern()->id());
   EXPECT_FALSE(condition_set->IsMatch(matching_patterns, url1));
 
   matching_patterns.insert(m2.string_pattern()->id());
   EXPECT_TRUE(condition_set->IsMatch(matching_patterns, url1));
   EXPECT_FALSE(condition_set->IsMatch(matching_patterns, url2));
 
   // Test scheme filters.
   scoped_refptr<URLMatcherConditionSet> condition_set2(
-      new URLMatcherConditionSet(1,
-                                 conditions,
-                                 scoped_ptr<URLMatcherSchemeFilter>(
+      new URLMatcherConditionSet(1, conditions,
+                                 std::unique_ptr<URLMatcherSchemeFilter>(
                                      new URLMatcherSchemeFilter("https")),
-                                 scoped_ptr<URLMatcherPortFilter>()));
+                                 std::unique_ptr<URLMatcherPortFilter>()));
   EXPECT_FALSE(condition_set2->IsMatch(matching_patterns, url1));
   scoped_refptr<URLMatcherConditionSet> condition_set3(
-      new URLMatcherConditionSet(1,
-                                 conditions,
-                                 scoped_ptr<URLMatcherSchemeFilter>(
+      new URLMatcherConditionSet(1, conditions,
+                                 std::unique_ptr<URLMatcherSchemeFilter>(
                                      new URLMatcherSchemeFilter("http")),
-                                 scoped_ptr<URLMatcherPortFilter>()));
+                                 std::unique_ptr<URLMatcherPortFilter>()));
   EXPECT_TRUE(condition_set3->IsMatch(matching_patterns, url1));
 
   // Test port filters.
   std::vector<URLMatcherPortFilter::Range> ranges;
   ranges.push_back(URLMatcherPortFilter::CreateRange(80));
-  scoped_ptr<URLMatcherPortFilter> filter(new URLMatcherPortFilter(ranges));
+  std::unique_ptr<URLMatcherPortFilter> filter(
+      new URLMatcherPortFilter(ranges));
   scoped_refptr<URLMatcherConditionSet> condition_set4(
       new URLMatcherConditionSet(1, conditions,
-                                 scoped_ptr<URLMatcherSchemeFilter>(),
+                                 std::unique_ptr<URLMatcherSchemeFilter>(),
                                  std::move(filter)));
   EXPECT_TRUE(condition_set4->IsMatch(matching_patterns, url1));
   EXPECT_TRUE(condition_set4->IsMatch(matching_patterns, url3));
   EXPECT_FALSE(condition_set4->IsMatch(matching_patterns, url4));
 
   // Test regex patterns.
   matching_patterns.clear();
   URLMatcherCondition r1 = factory.CreateURLMatchesCondition("/fo?oo");
   std::set<URLMatcherCondition> regex_conditions;
   regex_conditions.insert(r1);
@@ skipping 40 matching lines @@
 
   URLQueryElementMatcherCondition q1(key,
                                      value,
                                      query_value_match_type,
                                      query_element_type,
                                      match_type,
                                      &factory);
   URLMatcherConditionSet::QueryConditions query_conditions;
   query_conditions.insert(q1);
 
-  scoped_ptr<URLMatcherSchemeFilter> scheme_filter;
-  scoped_ptr<URLMatcherPortFilter> port_filter;
+  std::unique_ptr<URLMatcherSchemeFilter> scheme_filter;
+  std::unique_ptr<URLMatcherPortFilter> port_filter;
 
   scoped_refptr<URLMatcherConditionSet> condition_set(
       new URLMatcherConditionSet(1, conditions, query_conditions,
                                  std::move(scheme_filter),
                                  std::move(port_filter)));
 
   GURL url("http://www.example.com/foo?" + url_query);
 
   URLMatcher matcher;
   URLMatcherConditionSet::Vector vector;
@@ skipping 404 matching lines @@
   conditions.insert(factory->CreateOriginAndPathMatchesCondition("val"));
   const int kConditionSetId = 1;
   URLMatcherConditionSet::Vector insert;
   insert.push_back(make_scoped_refptr(
       new URLMatcherConditionSet(kConditionSetId, conditions)));
   matcher.AddConditionSets(insert);
   EXPECT_EQ(0u, matcher.MatchURL(url).size());
 }
 
 }  // namespace url_matcher