Use std::unique_ptr for base::DictionaryValue and base::ListValue's internal store.

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>
@@ skipping 302 matching lines @@
   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 std::unique_ptr<StringMatchTest> Create(const base::Value* data,
+    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,
@@ skipping 76 matching lines @@
 }
 
 HeaderMatcher::HeaderMatcher(
     std::vector<std::unique_ptr<const HeaderMatchTest>> tests)
     : tests_(std::move(tests)) {}
 
 // HeaderMatcher::StringMatchTest implementation.
 
 // static
 std::unique_ptr<HeaderMatcher::StringMatchTest>
-HeaderMatcher::StringMatchTest::Create(const base::Value* data,
+HeaderMatcher::StringMatchTest::Create(const base::Value& data,
                                        MatchType type,
                                        bool case_sensitive) {
   std::string str;
-  CHECK(data->GetAsString(&str));
-  return std::unique_ptr<StringMatchTest>(
-      new StringMatchTest(str, type, case_sensitive));
+  CHECK(data.GetAsString(&str));
+  return base::WrapUnique(new StringMatchTest(str, type, case_sensitive));

[dcheng, 2016/05/24 17:09:28]

I usually don't bundle unrelated cleanups, but this one was particularly
egregious, since the code below releases the unique_ptr and then rewraps it.

 }
 
 HeaderMatcher::StringMatchTest::~StringMatchTest() {}
 
 bool HeaderMatcher::StringMatchTest::Matches(
     const std::string& str) const {
   switch (type_) {
     case kPrefix:
       return base::StartsWith(str, data_, case_sensitive_);
     case kSuffix:
@@ skipping 67 matching lines @@
       return std::unique_ptr<const HeaderMatchTest>();
     }
     const base::Value* content = &it.value();
 
     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(base::WrapUnique(
-              StringMatchTest::Create(*it, match_type, !is_name).release()));
+        for (const auto& it : *list) {
+          tests->push_back(StringMatchTest::Create(*it, match_type, !is_name));
         }
         break;
       }
       case base::Value::TYPE_STRING: {
-        tests->push_back(base::WrapUnique(
-            StringMatchTest::Create(content, match_type, !is_name).release()));
+        tests->push_back(
+            StringMatchTest::Create(*content, match_type, !is_name));
         break;
       }
       default: {
         NOTREACHED();  // JSON schema type checking should prevent this.
         return std::unique_ptr<const HeaderMatchTest>();
       }
     }
   }
 
   return std::unique_ptr<const HeaderMatchTest>(
@@ skipping 344 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