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

extensions/renderer/api_binding.cc

 // Copyright 2016 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/renderer/api_binding.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 131 matching lines @@
       weak_factory_(this) {
   // TODO(devlin): It might make sense to instantiate the object_template_
   // directly here, which would avoid the need to hold on to
   // |property_definitions_| and |enums_|. However, there are *some* cases where
   // we don't immediately stamp out an API from the template following
   // construction.
 
   if (function_definitions) {
     for (const auto& func : *function_definitions) {
       const base::DictionaryValue* func_dict = nullptr;
-      CHECK(func->GetAsDictionary(&func_dict));
+      CHECK(func.GetAsDictionary(&func_dict));
       std::string name;
       CHECK(func_dict->GetString("name", &name));
 
       const base::ListValue* params = nullptr;
       CHECK(func_dict->GetList("parameters", &params));
       auto signature = base::MakeUnique<APISignature>(*params);
       std::string full_name =
           base::StringPrintf("%s.%s", api_name_.c_str(), name.c_str());
       methods_[name] = base::MakeUnique<MethodData>(full_name, signature.get());
       type_refs->AddAPIMethodSignature(full_name, std::move(signature));
     }
   }
 
   if (type_definitions) {
     for (const auto& type : *type_definitions) {
       const base::DictionaryValue* type_dict = nullptr;
-      CHECK(type->GetAsDictionary(&type_dict));
+      CHECK(type.GetAsDictionary(&type_dict));
       std::string id;
       CHECK(type_dict->GetString("id", &id));
       auto argument_spec = base::MakeUnique<ArgumentSpec>(*type_dict);
       const std::set<std::string>& enum_values = argument_spec->enum_values();
       if (!enum_values.empty()) {
         // Type names may be prefixed by the api name. If so, remove the prefix.
         base::Optional<std::string> stripped_id;
         if (base::StartsWith(id, api_name_, base::CompareCase::SENSITIVE))
           stripped_id = id.substr(api_name_.size() + 1);  // +1 for trailing '.'
         std::vector<EnumEntry>& entries =
             enums_[stripped_id ? *stripped_id : id];
         entries.reserve(enum_values.size());
         for (const auto& enum_value : enum_values) {
           entries.push_back(
               std::make_pair(enum_value, GetJSEnumEntryName(enum_value)));
         }
       }
       type_refs->AddSpec(id, std::move(argument_spec));
       // Some types, like storage.StorageArea, have functions associated with
       // them. Cache the function signatures in the type map.
       const base::ListValue* type_functions = nullptr;
       if (type_dict->GetList("functions", &type_functions)) {
         for (const auto& func : *type_functions) {
           const base::DictionaryValue* func_dict = nullptr;
-          CHECK(func->GetAsDictionary(&func_dict));
+          CHECK(func.GetAsDictionary(&func_dict));
           std::string function_name;
           CHECK(func_dict->GetString("name", &function_name));
 
           const base::ListValue* params = nullptr;
           CHECK(func_dict->GetList("parameters", &params));
           type_refs->AddTypeMethodSignature(
               base::StringPrintf("%s.%s", id.c_str(), function_name.c_str()),
               base::MakeUnique<APISignature>(*params));
         }
       }
     }
   }
 
   if (event_definitions) {
     events_.reserve(event_definitions->GetSize());
     for (const auto& event : *event_definitions) {
       const base::DictionaryValue* event_dict = nullptr;
-      CHECK(event->GetAsDictionary(&event_dict));
+      CHECK(event.GetAsDictionary(&event_dict));
       std::string name;
       CHECK(event_dict->GetString("name", &name));
       std::string full_name =
           base::StringPrintf("%s.%s", api_name_.c_str(), name.c_str());
       events_.push_back(base::MakeUnique<EventData>(
           std::move(name), std::move(full_name), event_handler));
     }
   }
 }
 
@@ skipping 240 matching lines @@
   if (invalid_invocation) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback);
 }
 
 }  // namespace extensions