[Extensions Bindings] Store API type methods in the reference map

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 167 matching lines @@
           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));
+          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));
       std::string name;
       CHECK(event_dict->GetString("name", &name));
@@ skipping 254 matching lines @@
   if (invalid_invocation) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback);
 }
 
 }  // namespace extensions