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

components/policy/core/common/schema.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/policy/core/common/schema.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 #include <algorithm>
@@ skipping 601 matching lines @@
     *error = "Enum attribute must be non-empty";
     return false;
   }
   int offset_begin;
   int offset_end;
   if (type == base::Value::Type::INTEGER) {
     offset_begin = static_cast<int>(int_enums_.size());
     int value;
     for (base::ListValue::const_iterator it = possible_values->begin();
          it != possible_values->end(); ++it) {
-      if (!it->GetAsInteger(&value)) {
+      if (!(*it)->GetAsInteger(&value)) {
         *error = "Invalid enumeration member type";
         return false;
       }
       int_enums_.push_back(value);
     }
     offset_end = static_cast<int>(int_enums_.size());
   } else if (type == base::Value::Type::STRING) {
     offset_begin = static_cast<int>(string_enums_.size());
     std::string value;
     for (base::ListValue::const_iterator it = possible_values->begin();
          it != possible_values->end(); ++it) {
-      if (!it->GetAsString(&value)) {
+      if (!(*it)->GetAsString(&value)) {
         *error = "Invalid enumeration member type";
         return false;
       }
       strings_.push_back(value);
       string_enums_.push_back(strings_.back().c_str());
     }
     offset_end = static_cast<int>(string_enums_.size());
   } else {
     *error = "Enumeration is only supported for integer and string.";
     return false;
@@ skipping 174 matching lines @@
             AddDictKeyPrefixToPath(it.key(), error_path);
             if (!StrategyAllowInvalidOnTopLevel(strategy))
               return false;
           }
         }
       }
     }
   } else if (value.GetAsList(&list)) {
     for (base::ListValue::const_iterator it = list->begin(); it != list->end();
          ++it) {
-      if (!GetItems().Validate(*it, StrategyForNextLevel(strategy), error_path,
+      if (!*it ||
+          !GetItems().Validate(**it,
+                               StrategyForNextLevel(strategy),
+                               error_path,
                                error)) {
         // Invalid list item was detected.
         AddListIndexPrefixToPath(it - list->begin(), error_path);
         if (!StrategyAllowInvalidOnTopLevel(strategy))
           return false;
       }
     }
   } else if (value.GetAsInteger(&int_value)) {
     if (node_->extra != kInvalid &&
         !ValidateIntegerRestriction(node_->extra, int_value)) {
@@ skipping 262 matching lines @@
     return false;
   } else {
     int index = rnode->string_pattern_restriction.pattern_index;
     DCHECK(index == rnode->string_pattern_restriction.pattern_index_backup);
     re2::RE2* regex = storage_->CompileRegex(*storage_->string_enums(index));
     return re2::RE2::PartialMatch(str, *regex);
   }
 }
 
 }  // namespace policy