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

extensions/browser/api/declarative_webrequest/webrequest_condition_attribute.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_attribute.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/public/browser/resource_request_info.h"
 #include "extensions/browser/api/declarative/deduping_factory.h"
 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_condition.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
 #include "extensions/common/error_utils.h"
@@ skipping 272 matching lines @@
 // headers. This is a helper class to header-related condition attributes.
 // It contains a set of test groups. A name-value pair satisfies the whole
 // set of test groups iff it passes at least one test group.
 class HeaderMatcher {
  public:
   ~HeaderMatcher();
 
   // Creates an instance based on a list |tests| of test groups, encoded as
   // dictionaries of the type declarativeWebRequest.HeaderFilter (see
   // declarative_web_request.json).
-  static scoped_ptr<const HeaderMatcher> Create(const base::ListValue* tests);
+  static std::unique_ptr<const HeaderMatcher> Create(
+      const base::ListValue* tests);
 
   // Does |this| match the header "|name|: |value|"?
   bool TestNameValue(const std::string& name, const std::string& value) const;
 
  private:
   // Represents a single string-matching test.
   class StringMatchTest {
    public:
     enum MatchType { kPrefix, kSuffix, kEquals, kContains };
 
     // |data| is the pattern to be matched in the position given by |type|.
     // Note that |data| must point to a StringValue object.
-    static scoped_ptr<StringMatchTest> Create(const base::Value* data,
-                                              MatchType type,
-                                              bool case_sensitive);
+    static std::unique_ptr<StringMatchTest> Create(const base::Value* data,
+                                                   MatchType type,
+                                                   bool case_sensitive);
     ~StringMatchTest();
 
     // Does |str| pass |this| StringMatchTest?
     bool Matches(const std::string& str) const;
 
    private:
     StringMatchTest(const std::string& data,
                     MatchType type,
                     bool case_sensitive);
 
     const std::string data_;
     const MatchType type_;
     const base::CompareCase case_sensitive_;
     DISALLOW_COPY_AND_ASSIGN(StringMatchTest);
   };
 
   // Represents a test group -- a set of string matching tests to be applied to
   // both the header name and value.
   class HeaderMatchTest {
    public:
     ~HeaderMatchTest();
 
     // Gets the test group description in |tests| and creates the corresponding
     // HeaderMatchTest. On failure returns NULL.
-    static scoped_ptr<const HeaderMatchTest> Create(
+    static std::unique_ptr<const HeaderMatchTest> Create(
         const base::DictionaryValue* tests);
 
     // Does the header "|name|: |value|" match all tests in |this|?
     bool Matches(const std::string& name, const std::string& value) const;
 
    private:
     // Takes ownership of the content of both |name_match| and |value_match|.
-    HeaderMatchTest(std::vector<scoped_ptr<const StringMatchTest>> name_match,
-                    std::vector<scoped_ptr<const StringMatchTest>> value_match);
+    HeaderMatchTest(
+        std::vector<std::unique_ptr<const StringMatchTest>> name_match,
+        std::vector<std::unique_ptr<const StringMatchTest>> value_match);
 
     // Tests to be passed by a header's name.
-    const std::vector<scoped_ptr<const StringMatchTest>> name_match_;
+    const std::vector<std::unique_ptr<const StringMatchTest>> name_match_;
     // Tests to be passed by a header's value.
-    const std::vector<scoped_ptr<const StringMatchTest>> value_match_;
+    const std::vector<std::unique_ptr<const StringMatchTest>> value_match_;
 
     DISALLOW_COPY_AND_ASSIGN(HeaderMatchTest);
   };
 
-  explicit HeaderMatcher(std::vector<scoped_ptr<const HeaderMatchTest>> tests);
+  explicit HeaderMatcher(
+      std::vector<std::unique_ptr<const HeaderMatchTest>> tests);
 
-  const std::vector<scoped_ptr<const HeaderMatchTest>> tests_;
+  const std::vector<std::unique_ptr<const HeaderMatchTest>> tests_;
 
   DISALLOW_COPY_AND_ASSIGN(HeaderMatcher);
 };
 
 // HeaderMatcher implementation.
 
 HeaderMatcher::~HeaderMatcher() {}
 
 // static
-scoped_ptr<const HeaderMatcher> HeaderMatcher::Create(
+std::unique_ptr<const HeaderMatcher> HeaderMatcher::Create(
     const base::ListValue* tests) {
-  std::vector<scoped_ptr<const HeaderMatchTest>> header_tests;
+  std::vector<std::unique_ptr<const HeaderMatchTest>> header_tests;
   for (base::ListValue::const_iterator it = tests->begin();
        it != tests->end(); ++it) {
     const base::DictionaryValue* tests = NULL;
     if (!(*it)->GetAsDictionary(&tests))
-      return scoped_ptr<const HeaderMatcher>();
+      return std::unique_ptr<const HeaderMatcher>();
 
-    scoped_ptr<const HeaderMatchTest> header_test(
+    std::unique_ptr<const HeaderMatchTest> header_test(
         HeaderMatchTest::Create(tests));
     if (header_test.get() == NULL)
-      return scoped_ptr<const HeaderMatcher>();
+      return std::unique_ptr<const HeaderMatcher>();
     header_tests.push_back(std::move(header_test));
   }
 
-  return scoped_ptr<const HeaderMatcher>(
+  return std::unique_ptr<const HeaderMatcher>(
       new HeaderMatcher(std::move(header_tests)));
 }
 
 bool HeaderMatcher::TestNameValue(const std::string& name,
                                   const std::string& value) const {
   for (size_t i = 0; i < tests_.size(); ++i) {
     if (tests_[i]->Matches(name, value))
       return true;
   }
   return false;
 }
 
 HeaderMatcher::HeaderMatcher(
-    std::vector<scoped_ptr<const HeaderMatchTest>> tests)
+    std::vector<std::unique_ptr<const HeaderMatchTest>> tests)
     : tests_(std::move(tests)) {}
 
 // HeaderMatcher::StringMatchTest implementation.
 
 // static
-scoped_ptr<HeaderMatcher::StringMatchTest>
+std::unique_ptr<HeaderMatcher::StringMatchTest>
 HeaderMatcher::StringMatchTest::Create(const base::Value* data,
                                        MatchType type,
                                        bool case_sensitive) {
   std::string str;
   CHECK(data->GetAsString(&str));
-  return scoped_ptr<StringMatchTest>(
+  return std::unique_ptr<StringMatchTest>(
       new StringMatchTest(str, type, case_sensitive));
 }
 
 HeaderMatcher::StringMatchTest::~StringMatchTest() {}
 
 bool HeaderMatcher::StringMatchTest::Matches(
     const std::string& str) const {
   switch (type_) {
     case kPrefix:
       return base::StartsWith(str, data_, case_sensitive_);
@@ skipping 19 matching lines @@
                                                 MatchType type,
                                                 bool case_sensitive)
     : data_(data),
       type_(type),
       case_sensitive_(case_sensitive ? base::CompareCase::SENSITIVE
                                      : base::CompareCase::INSENSITIVE_ASCII) {}
 
 // HeaderMatcher::HeaderMatchTest implementation.
 
 HeaderMatcher::HeaderMatchTest::HeaderMatchTest(
-    std::vector<scoped_ptr<const StringMatchTest>> name_match,
-    std::vector<scoped_ptr<const StringMatchTest>> value_match)
+    std::vector<std::unique_ptr<const StringMatchTest>> name_match,
+    std::vector<std::unique_ptr<const StringMatchTest>> value_match)
     : name_match_(std::move(name_match)),
       value_match_(std::move(value_match)) {}
 
 HeaderMatcher::HeaderMatchTest::~HeaderMatchTest() {}
 
 // static
-scoped_ptr<const HeaderMatcher::HeaderMatchTest>
+std::unique_ptr<const HeaderMatcher::HeaderMatchTest>
 HeaderMatcher::HeaderMatchTest::Create(const base::DictionaryValue* tests) {
-  std::vector<scoped_ptr<const StringMatchTest>> name_match;
-  std::vector<scoped_ptr<const StringMatchTest>> value_match;
+  std::vector<std::unique_ptr<const StringMatchTest>> name_match;
+  std::vector<std::unique_ptr<const StringMatchTest>> value_match;
 
   for (base::DictionaryValue::Iterator it(*tests);
        !it.IsAtEnd(); it.Advance()) {
     bool is_name = false;  // Is this test for header name?
     StringMatchTest::MatchType match_type;
     if (it.key() == keys::kNamePrefixKey) {
       is_name = true;
       match_type = StringMatchTest::kPrefix;
     } else if (it.key() == keys::kNameSuffixKey) {
       is_name = true;
       match_type = StringMatchTest::kSuffix;
     } else if (it.key() == keys::kNameContainsKey) {
       is_name = true;
       match_type = StringMatchTest::kContains;
     } else if (it.key() == keys::kNameEqualsKey) {
       is_name = true;
       match_type = StringMatchTest::kEquals;
     } else if (it.key() == keys::kValuePrefixKey) {
       match_type = StringMatchTest::kPrefix;
     } else if (it.key() == keys::kValueSuffixKey) {
       match_type = StringMatchTest::kSuffix;
     } else if (it.key() == keys::kValueContainsKey) {
       match_type = StringMatchTest::kContains;
     } else if (it.key() == keys::kValueEqualsKey) {
       match_type = StringMatchTest::kEquals;
     } else {
       NOTREACHED();  // JSON schema type checking should prevent this.
-      return scoped_ptr<const HeaderMatchTest>();
+      return std::unique_ptr<const HeaderMatchTest>();
     }
     const base::Value* content = &it.value();
 
-    std::vector<scoped_ptr<const StringMatchTest>>* tests =
+    std::vector<std::unique_ptr<const StringMatchTest>>* tests =
         is_name ? &name_match : &value_match;
     switch (content->GetType()) {
       case base::Value::TYPE_LIST: {
         const base::ListValue* list = NULL;
         CHECK(content->GetAsList(&list));
         for (base::ListValue::const_iterator it = list->begin();
              it != list->end(); ++it) {
-          tests->push_back(make_scoped_ptr(
+          tests->push_back(base::WrapUnique(
               StringMatchTest::Create(*it, match_type, !is_name).release()));
         }
         break;
       }
       case base::Value::TYPE_STRING: {
-        tests->push_back(make_scoped_ptr(
+        tests->push_back(base::WrapUnique(
             StringMatchTest::Create(content, match_type, !is_name).release()));
         break;
       }
       default: {
         NOTREACHED();  // JSON schema type checking should prevent this.
-        return scoped_ptr<const HeaderMatchTest>();
+        return std::unique_ptr<const HeaderMatchTest>();
       }
     }
   }
 
-  return scoped_ptr<const HeaderMatchTest>(
+  return std::unique_ptr<const HeaderMatchTest>(
       new HeaderMatchTest(std::move(name_match), std::move(value_match)));
 }
 
 bool HeaderMatcher::HeaderMatchTest::Matches(const std::string& name,
                                              const std::string& value) const {
   for (size_t i = 0; i < name_match_.size(); ++i) {
     if (!name_match_[i]->Matches(name))
       return false;
   }
 
   for (size_t i = 0; i < value_match_.size(); ++i) {
     if (!value_match_[i]->Matches(value))
       return false;
   }
 
   return true;
 }
 
 //
 // WebRequestConditionAttributeRequestHeaders
 //
 
 WebRequestConditionAttributeRequestHeaders::
     WebRequestConditionAttributeRequestHeaders(
-        scoped_ptr<const HeaderMatcher> header_matcher,
+        std::unique_ptr<const HeaderMatcher> header_matcher,
         bool positive)
     : header_matcher_(std::move(header_matcher)), positive_(positive) {}
 
 WebRequestConditionAttributeRequestHeaders::
 ~WebRequestConditionAttributeRequestHeaders() {}
 
 namespace {
 
-scoped_ptr<const HeaderMatcher> PrepareHeaderMatcher(
+std::unique_ptr<const HeaderMatcher> PrepareHeaderMatcher(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   const base::ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
-    return scoped_ptr<const HeaderMatcher>();
+    return std::unique_ptr<const HeaderMatcher>();
   }
 
-  scoped_ptr<const HeaderMatcher> header_matcher(
+  std::unique_ptr<const HeaderMatcher> header_matcher(
       HeaderMatcher::Create(value_as_list));
   if (header_matcher.get() == NULL)
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
   return header_matcher;
 }
 
 }  // namespace
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeRequestHeaders::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(name == keys::kRequestHeadersKey ||
          name == keys::kExcludeRequestHeadersKey);
 
-  scoped_ptr<const HeaderMatcher> header_matcher(
+  std::unique_ptr<const HeaderMatcher> header_matcher(
       PrepareHeaderMatcher(name, value, error));
   if (header_matcher.get() == NULL)
     return scoped_refptr<const WebRequestConditionAttribute>(NULL);
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeRequestHeaders(
           std::move(header_matcher), name == keys::kRequestHeadersKey));
 }
 
 int WebRequestConditionAttributeRequestHeaders::GetStages() const {
@@ skipping 35 matching lines @@
   // Comparing headers is too heavy, so we skip it entirely.
   return false;
 }
 
 //
 // WebRequestConditionAttributeResponseHeaders
 //
 
 WebRequestConditionAttributeResponseHeaders::
     WebRequestConditionAttributeResponseHeaders(
-        scoped_ptr<const HeaderMatcher> header_matcher,
+        std::unique_ptr<const HeaderMatcher> header_matcher,
         bool positive)
     : header_matcher_(std::move(header_matcher)), positive_(positive) {}
 
 WebRequestConditionAttributeResponseHeaders::
 ~WebRequestConditionAttributeResponseHeaders() {}
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeResponseHeaders::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(name == keys::kResponseHeadersKey ||
          name == keys::kExcludeResponseHeadersKey);
 
-  scoped_ptr<const HeaderMatcher> header_matcher(
+  std::unique_ptr<const HeaderMatcher> header_matcher(
       PrepareHeaderMatcher(name, value, error));
   if (header_matcher.get() == NULL)
     return scoped_refptr<const WebRequestConditionAttribute>(NULL);
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeResponseHeaders(
           std::move(header_matcher), name == keys::kResponseHeadersKey));
 }
 
 int WebRequestConditionAttributeResponseHeaders::GetStages() const {
@@ skipping 198 matching lines @@
 bool WebRequestConditionAttributeStages::Equals(
     const WebRequestConditionAttribute* other) const {
   if (!WebRequestConditionAttribute::Equals(other))
     return false;
   const WebRequestConditionAttributeStages* casted_other =
       static_cast<const WebRequestConditionAttributeStages*>(other);
   return allowed_stages_ == casted_other->allowed_stages_;
 }
 
 }  // namespace extensions