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

chrome/browser/android/vr_shell/gltf_parser.cc

 // Copyright 2017 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/android/vr_shell/gltf_parser.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 
@@ skipping 137 matching lines @@
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* mesh_dict;
     if (!it.value().GetAsDictionary(&mesh_dict))
       return false;
 
     auto mesh = base::MakeUnique<gltf::Mesh>();
     const base::ListValue* list;
     if (mesh_dict->GetList("primitives", &list)) {
       for (const auto& primitive_value : *list) {
         const base::DictionaryValue* primitive_dict;
-        if (!primitive_value->GetAsDictionary(&primitive_dict))
+        if (!primitive_value.GetAsDictionary(&primitive_dict))
           return false;
 
         auto primitive = ProcessPrimitive(*primitive_dict);
         if (!primitive)
           return false;
         mesh->primitives.push_back(std::move(primitive));
       }
     }
 
     mesh_ids_[it.key()] = asset_->AddMesh(std::move(mesh));
@@ skipping 34 matching lines @@
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* node_dict;
     if (!it.value().GetAsDictionary(&node_dict))
       return false;
 
     auto node = base::MakeUnique<gltf::Node>();
     const base::ListValue* list;
     if (node_dict->GetList("meshes", &list)) {
       std::string mesh_key;
       for (const auto& mesh_value : *list) {
-        if (!mesh_value->GetAsString(&mesh_key))
+        if (!mesh_value.GetAsString(&mesh_key))
           return false;
         auto mesh_it = mesh_ids_.find(mesh_key);
         if (mesh_it == mesh_ids_.end())
           return false;
         node->meshes.push_back(asset_->GetMesh(mesh_it->second));
       }
     }
 
     nodes[it.key()] = node.get();
     node_ids_[it.key()] = asset_->AddNode(std::move(node));
   }
 
   // Processing children after all nodes have been added to the asset.
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* node_dict;
     it.value().GetAsDictionary(&node_dict);
 
     gltf::Node* node = nodes[it.key()];
     const base::ListValue* list;
     if (node_dict->GetList("children", &list)) {
       std::string node_key;
       for (const auto& mesh_value : *list) {
-        if (!mesh_value->GetAsString(&node_key))
+        if (!mesh_value.GetAsString(&node_key))
           return false;
         auto node_it = nodes.find(node_key);
         if (node_it == nodes.end())
           return false;
         node->children.push_back(node_it->second);
       }
     }
   }
 
   return true;
 }
 
 bool GltfParser::SetScenes(const base::DictionaryValue& dict) {
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* scene_dict;
     if (!it.value().GetAsDictionary(&scene_dict))
       return false;
 
     auto scene = base::MakeUnique<gltf::Scene>();
     const base::ListValue* list;
     if (scene_dict->GetList("nodes", &list)) {
       std::string node_key;
       for (const auto& node_value : *list) {
-        if (!node_value->GetAsString(&node_key))
+        if (!node_value.GetAsString(&node_key))
           return false;
         auto node_it = node_ids_.find(node_key);
         if (node_it == node_ids_.end())
           return false;
         scene->nodes.push_back(asset_->GetNode(node_it->second));
       }
     }
 
     scene_ids_[it.key()] = asset_->AddScene(std::move(scene));
   }
   return true;
 }
 
 }  // namespace vr_shell