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

components/url_matcher/url_matcher_factory.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_factory.h"
 
 #include <algorithm>
 #include <cctype>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "components/url_matcher/url_matcher_constants.h"
 #include "components/url_matcher/url_matcher_helpers.h"
 #include "third_party/re2/src/re2/re2.h"
 
 namespace url_matcher {
 
 namespace helpers = url_matcher_helpers;
 namespace keys = url_matcher_constants;
@@ skipping 78 matching lines @@
 
 }  // namespace
 
 // static
 scoped_refptr<URLMatcherConditionSet>
 URLMatcherFactory::CreateFromURLFilterDictionary(
     URLMatcherConditionFactory* url_matcher_condition_factory,
     const base::DictionaryValue* url_filter_dict,
     URLMatcherConditionSet::ID id,
     std::string* error) {
-  scoped_ptr<URLMatcherSchemeFilter> url_matcher_schema_filter;
-  scoped_ptr<URLMatcherPortFilter> url_matcher_port_filter;
+  std::unique_ptr<URLMatcherSchemeFilter> url_matcher_schema_filter;
+  std::unique_ptr<URLMatcherPortFilter> url_matcher_port_filter;
   URLMatcherConditionSet::Conditions url_matcher_conditions;
 
   for (base::DictionaryValue::Iterator iter(*url_filter_dict);
        !iter.IsAtEnd(); iter.Advance()) {
     const std::string& condition_attribute_name = iter.key();
     const base::Value& condition_attribute_value = iter.value();
     if (IsURLMatcherConditionAttribute(condition_attribute_name)) {
       // Handle {host, path, ...}{Prefix, Suffix, Contains, Equals}.
       URLMatcherCondition url_matcher_condition =
           CreateURLMatcherCondition(
@@ skipping 87 matching lines @@
       *error = base::StringPrintf(
           kUnparseableRegexString, str_value.c_str(), regex.error().c_str());
       return URLMatcherCondition();
     }
   }
   return g_url_matcher_condition_factory_methods.Get().Call(
       url_matcher_condition_factory, condition_attribute_name, str_value);
 }
 
 // static
-scoped_ptr<URLMatcherSchemeFilter> URLMatcherFactory::CreateURLMatcherScheme(
-    const base::Value* value,
-    std::string* error) {
+std::unique_ptr<URLMatcherSchemeFilter>
+URLMatcherFactory::CreateURLMatcherScheme(const base::Value* value,
+                                          std::string* error) {
   std::vector<std::string> schemas;
   if (!helpers::GetAsStringVector(value, &schemas)) {
     *error = base::StringPrintf(kVectorOfStringsExpected, keys::kSchemesKey);
-    return scoped_ptr<URLMatcherSchemeFilter>();
+    return nullptr;
   }
   for (std::vector<std::string>::const_iterator it = schemas.begin();
        it != schemas.end(); ++it) {
     if (ContainsUpperCase(*it)) {
       *error = base::StringPrintf(kLowerCaseExpected, "Scheme");
-      return scoped_ptr<URLMatcherSchemeFilter>();
+      return nullptr;
     }
   }
-  return scoped_ptr<URLMatcherSchemeFilter>(
-      new URLMatcherSchemeFilter(schemas));
+  return base::WrapUnique(new URLMatcherSchemeFilter(schemas));
 }
 
 // static
-scoped_ptr<URLMatcherPortFilter> URLMatcherFactory::CreateURLMatcherPorts(
+std::unique_ptr<URLMatcherPortFilter> URLMatcherFactory::CreateURLMatcherPorts(
     const base::Value* value,
     std::string* error) {
   std::vector<URLMatcherPortFilter::Range> ranges;
   const base::ListValue* value_list = NULL;
   if (!value->GetAsList(&value_list)) {
     *error = kInvalidPortRanges;
-    return scoped_ptr<URLMatcherPortFilter>();
+    return nullptr;
   }
 
   for (base::ListValue::const_iterator i = value_list->begin();
        i != value_list->end(); ++i) {
     base::Value* entry = *i;
     int port = 0;
     base::ListValue* range = NULL;
     if (entry->GetAsInteger(&port)) {
       ranges.push_back(URLMatcherPortFilter::CreateRange(port));
     } else if (entry->GetAsList(&range)) {
       int from = 0, to = 0;
       if (range->GetSize() != 2u ||
           !range->GetInteger(0, &from) ||
           !range->GetInteger(1, &to)) {
         *error = kInvalidPortRanges;
-        return scoped_ptr<URLMatcherPortFilter>();
+        return nullptr;
       }
       ranges.push_back(URLMatcherPortFilter::CreateRange(from, to));
     } else {
       *error = kInvalidPortRanges;
-      return scoped_ptr<URLMatcherPortFilter>();
+      return nullptr;
     }
   }
 
-  return scoped_ptr<URLMatcherPortFilter>(new URLMatcherPortFilter(ranges));
+  return base::WrapUnique(new URLMatcherPortFilter(ranges));
 }
 
 }  // namespace url_matcher