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 156 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());
       const base::ListValue* filters = nullptr;
       bool supports_filters =
           event_dict->GetList("filters", &filters) && !filters->empty();
 
       std::vector<std::string> rule_actions;
       std::vector<std::string> rule_conditions;
       const base::DictionaryValue* options = nullptr;
       bool supports_rules = false;
       if (event_dict->GetDictionary("options", &options) &&
           options->GetBoolean("supportsRules", &supports_rules) &&
           supports_rules) {
         bool supports_listeners = false;
         DCHECK(options->GetBoolean("supportsListeners", &supports_listeners));
         DCHECK(!supports_listeners)
             << "Events cannot support rules and listeners.";
         auto get_values = [options](base::StringPiece name,
                                     std::vector<std::string>* out_value) {
           const base::ListValue* list = nullptr;
           CHECK(options->GetList(name, &list));
           for (const auto& entry : *list) {
-            DCHECK(entry->is_string());
-            out_value->push_back(entry->GetString());
+            DCHECK(entry.is_string());
+            out_value->push_back(entry.GetString());
           }
         };
         get_values("actions", &rule_actions);
         get_values("conditions", &rule_conditions);
       }
 
       events_.push_back(base::MakeUnique<EventData>(
           std::move(name), std::move(full_name), supports_filters,
           supports_rules, std::move(rule_actions), std::move(rule_conditions),
           this));
@@ skipping 255 matching lines @@
   if (invalid_invocation) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback);
 }
 
 }  // namespace extensions