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

chrome/browser/chromeos/platform_keys/key_permissions.cc

 // Copyright 2015 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 "chrome/browser/chromeos/platform_keys/key_permissions.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 229 matching lines @@
 void KeyPermissions::PermissionsForExtension::KeyEntriesFromState(
     const base::Value& state) {
   state_store_entries_.clear();
 
   const base::ListValue* entries = nullptr;
   if (!state.GetAsList(&entries)) {
     LOG(ERROR) << "Found a state store of wrong type.";
     return;
   }
   for (const auto& entry : *entries) {
+    if (!entry) {
+      LOG(ERROR) << "Found invalid NULL entry in PlatformKeys state store.";
+      continue;
+    }
+
     std::string spki_b64;
     const base::DictionaryValue* dict_entry = nullptr;
-    if (entry.GetAsString(&spki_b64)) {
+    if (entry->GetAsString(&spki_b64)) {
       // This handles the case that the store contained a plain list of base64
       // and DER-encoded SPKIs from an older version of ChromeOS.
       KeyEntry new_entry(spki_b64);
       new_entry.sign_once = true;
       state_store_entries_.push_back(new_entry);
-    } else if (entry.GetAsDictionary(&dict_entry)) {
+    } else if (entry->GetAsDictionary(&dict_entry)) {
       dict_entry->GetStringWithoutPathExpansion(kStateStoreSPKI, &spki_b64);
       KeyEntry new_entry(spki_b64);
       dict_entry->GetBooleanWithoutPathExpansion(kStateStoreSignOnce,
                                                  &new_entry.sign_once);
       dict_entry->GetBooleanWithoutPathExpansion(kStateStoreSignUnlimited,
                                                  &new_entry.sign_unlimited);
       state_store_entries_.push_back(new_entry);
     } else {
-      LOG(ERROR) << "Found invalid entry of type " << entry.GetType()
+      LOG(ERROR) << "Found invalid entry of type " << entry->GetType()
                  << " in PlatformKeys state store.";
       continue;
     }
   }
 }
 
 std::unique_ptr<base::Value>
 KeyPermissions::PermissionsForExtension::KeyEntriesToState() {
   std::unique_ptr<base::ListValue> new_state(new base::ListValue);
   for (const KeyEntry& entry : state_store_entries_) {
@@ skipping 110 matching lines @@
   const base::DictionaryValue* platform_keys =
       profile_prefs_->GetDictionary(prefs::kPlatformKeys);
 
   const base::DictionaryValue* key_entry = nullptr;
   platform_keys->GetDictionaryWithoutPathExpansion(public_key_spki_der_b64,
                                                    &key_entry);
   return key_entry;
 }
 
 }  // namespace chromeos