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

extensions/browser/verified_contents.cc

 // Copyright 2014 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/verified_contents.h"
 
 #include <stddef.h>
 
 #include "base/base64url.h"
 #include "base/files/file_util.h"
@@ skipping 25 matching lines @@
 const char kRootHashKey[] = "root_hash";
 const char kSignatureKey[] = "signature";
 const char kSignaturesKey[] = "signatures";
 const char kSignedContentKey[] = "signed_content";
 const char kTreeHashPerFile[] = "treehash per file";
 const char kTreeHash[] = "treehash";
 const char kWebstoreKId[] = "webstore";
 
 // Helper function to iterate over a list of dictionaries, returning the
 // dictionary that has |key| -> |value| in it, if any, or NULL.
-const DictionaryValue* FindDictionaryWithValue(const ListValue* list,
-                                               const std::string& key,
-                                               const std::string& value) {
+DictionaryValue* FindDictionaryWithValue(const ListValue* list,
+                                         const std::string& key,
+                                         const std::string& value) {
   for (const auto& i : *list) {
-    const DictionaryValue* dictionary;
-    if (!i.GetAsDictionary(&dictionary))
+    DictionaryValue* dictionary;
+    if (!i->GetAsDictionary(&dictionary))
       continue;
     std::string found_value;
     if (dictionary->GetString(key, &found_value) && found_value == value)
       return dictionary;
   }
   return NULL;
 }
 
 }  // namespace
 
@@ skipping 179 matching lines @@
   // Find the "treehash per file" signed content, e.g.
   // [
   //   {
   //     "description": "treehash per file",
   //     "signed_content": {
   //       "signatures": [ ... ],
   //       "payload": "..."
   //     }
   //   }
   // ]
-  const DictionaryValue* dictionary =
+  DictionaryValue* dictionary =
       FindDictionaryWithValue(top_list, kDescriptionKey, kTreeHashPerFile);
-  const DictionaryValue* signed_content = NULL;
+  DictionaryValue* signed_content = NULL;
   if (!dictionary ||
       !dictionary->GetDictionaryWithoutPathExpansion(kSignedContentKey,
                                                      &signed_content)) {
     return false;
   }
 
-  const ListValue* signatures = NULL;
+  ListValue* signatures = NULL;
   if (!signed_content->GetList(kSignaturesKey, &signatures))
     return false;
 
-  const DictionaryValue* signature_dict =
+  DictionaryValue* signature_dict =
       FindDictionaryWithValue(signatures, kHeaderKidKey, kWebstoreKId);
   if (!signature_dict)
     return false;
 
   std::string protected_value;
   std::string encoded_signature;
   std::string decoded_signature;
   if (!signature_dict->GetString(kProtectedKey, &protected_value) ||
       !signature_dict->GetString(kSignatureKey, &encoded_signature) ||
       !base::Base64UrlDecode(encoded_signature,
@@ skipping 42 matching lines @@
       reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
 
   if (!signature_verifier.VerifyFinal()) {
     VLOG(1) << "Could not verify signature - VerifyFinal failure";
     return false;
   }
   return true;
 }
 
 }  // namespace extensions