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

extensions/browser/api/declarative_webrequest/webrequest_condition.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_condition.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 107 matching lines @@
 
 void WebRequestCondition::GetURLMatcherConditionSets(
     URLMatcherConditionSet::Vector* condition_sets) const {
   if (url_matcher_conditions_.get())
     condition_sets->push_back(url_matcher_conditions_);
   if (first_party_url_matcher_conditions_.get())
     condition_sets->push_back(first_party_url_matcher_conditions_);
 }
 
 // static
-scoped_ptr<WebRequestCondition> WebRequestCondition::Create(
+std::unique_ptr<WebRequestCondition> WebRequestCondition::Create(
     const Extension* extension,
     URLMatcherConditionFactory* url_matcher_condition_factory,
     const base::Value& condition,
     std::string* error) {
   const base::DictionaryValue* condition_dict = NULL;
   if (!condition.GetAsDictionary(&condition_dict)) {
     *error = kExpectedDictionary;
-    return scoped_ptr<WebRequestCondition>();
+    return std::unique_ptr<WebRequestCondition>();
   }
 
   // Verify that we are dealing with a Condition whose type we understand.
   std::string instance_type;
   if (!condition_dict->GetString(keys::kInstanceTypeKey, &instance_type)) {
     *error = kConditionWithoutInstanceType;
-    return scoped_ptr<WebRequestCondition>();
+    return std::unique_ptr<WebRequestCondition>();
   }
   if (instance_type != keys::kRequestMatcherType) {
     *error = kExpectedOtherConditionType;
-    return scoped_ptr<WebRequestCondition>();
+    return std::unique_ptr<WebRequestCondition>();
   }
 
   WebRequestConditionAttributes attributes;
   scoped_refptr<URLMatcherConditionSet> url_matcher_condition_set;
   scoped_refptr<URLMatcherConditionSet> first_party_url_matcher_condition_set;
 
   for (base::DictionaryValue::Iterator iter(*condition_dict);
        !iter.IsAtEnd(); iter.Advance()) {
     const std::string& condition_attribute_name = iter.key();
     const base::Value& condition_attribute_value = iter.value();
@@ skipping 20 matching lines @@
     } else {
       scoped_refptr<const WebRequestConditionAttribute> attribute =
           WebRequestConditionAttribute::Create(
               condition_attribute_name,
               &condition_attribute_value,
               error);
       if (attribute.get())
         attributes.push_back(attribute);
     }
     if (!error->empty())
-      return scoped_ptr<WebRequestCondition>();
+      return std::unique_ptr<WebRequestCondition>();
   }
 
-  scoped_ptr<WebRequestCondition> result(
-      new WebRequestCondition(url_matcher_condition_set,
-                              first_party_url_matcher_condition_set,
-                              attributes));
+  std::unique_ptr<WebRequestCondition> result(new WebRequestCondition(
+      url_matcher_condition_set, first_party_url_matcher_condition_set,
+      attributes));
 
   if (!result->stages()) {
     *error = kConditionCannotBeFulfilled;
-    return scoped_ptr<WebRequestCondition>();
+    return std::unique_ptr<WebRequestCondition>();
   }
 
   return result;
 }
 
 }  // namespace extensions