Change base::Value::ListStorage to std::vector<base::Value>

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 217 matching lines @@
 
   const base::ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_refptr<const WebRequestConditionAttribute>(NULL);
   }
   std::vector<std::string> content_types;
   for (base::ListValue::const_iterator it = value_as_list->begin();
        it != value_as_list->end(); ++it) {
     std::string content_type;
-    if (!(*it)->GetAsString(&content_type)) {
+    if (!it->GetAsString(&content_type)) {
       *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
       return scoped_refptr<const WebRequestConditionAttribute>(NULL);
     }
     content_types.push_back(content_type);
   }
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeContentType(
           content_types, name == keys::kContentTypeKey));
 }
@@ skipping 128 matching lines @@
 
 HeaderMatcher::~HeaderMatcher() {}
 
 // static
 std::unique_ptr<const HeaderMatcher> HeaderMatcher::Create(
     const base::ListValue* 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))
+    if (!it->GetAsDictionary(&tests))
       return std::unique_ptr<const HeaderMatcher>();
 
     std::unique_ptr<const HeaderMatchTest> header_test(
         HeaderMatchTest::Create(tests));
     if (header_test.get() == NULL)
       return std::unique_ptr<const HeaderMatcher>();
     header_tests.push_back(std::move(header_test));
   }
 
   return std::unique_ptr<const HeaderMatcher>(
@@ skipping 104 matching lines @@
     }
     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 (const auto& it : *list) {
-          tests->push_back(StringMatchTest::Create(*it, match_type, !is_name));
+          tests->push_back(StringMatchTest::Create(it, match_type, !is_name));
         }
         break;
       }
       case base::Value::Type::STRING: {
         tests->push_back(
             StringMatchTest::Create(*content, match_type, !is_name));
         break;
       }
       default: {
         NOTREACHED();  // JSON schema type checking should prevent this.
@@ skipping 280 matching lines @@
 // success, false otherwise.
 bool ParseListOfStages(const base::Value& value, int* out_stages) {
   const base::ListValue* list = NULL;
   if (!value.GetAsList(&list))
     return false;
 
   int stages = 0;
   std::string stage_name;
   for (base::ListValue::const_iterator it = list->begin();
        it != list->end(); ++it) {
-    if (!((*it)->GetAsString(&stage_name)))
+    if (!(it->GetAsString(&stage_name)))
       return false;
     if (stage_name == keys::kOnBeforeRequestEnum) {
       stages |= ON_BEFORE_REQUEST;
     } else if (stage_name == keys::kOnBeforeSendHeadersEnum) {
       stages |= ON_BEFORE_SEND_HEADERS;
     } else if (stage_name == keys::kOnHeadersReceivedEnum) {
       stages |= ON_HEADERS_RECEIVED;
     } else if (stage_name == keys::kOnAuthRequiredEnum) {
       stages |= ON_AUTH_REQUIRED;
     } else {
@@ skipping 49 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