[Extensions Bindings] Make function definitions optional for an API.

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 46 matching lines @@
         return live_callback.get() == callback;
       }));
 #endif  // DCHECK_IS_ON()
 
   callback->Run(&args);
 }
 
 }  // namespace
 
 APIBinding::APIBinding(const std::string& api_name,
-                       const base::ListValue& function_definitions,
+                       const base::ListValue* function_definitions,
                        const base::ListValue* type_definitions,
                        const base::ListValue* event_definitions,
                        const APIMethodCallback& callback,
                        std::unique_ptr<APIBindingHooks> binding_hooks,
                        ArgumentSpec::RefMap* type_refs)
     : api_name_(api_name),
       method_callback_(callback),
       binding_hooks_(std::move(binding_hooks)),
       type_refs_(type_refs),
       weak_factory_(this) {
   DCHECK(!method_callback_.is_null());
-  for (const auto& func : function_definitions) {
-    const base::DictionaryValue* func_dict = nullptr;
-    CHECK(func->GetAsDictionary(&func_dict));
-    std::string name;
-    CHECK(func_dict->GetString("name", &name));
+  if (function_definitions) {
+    for (const auto& func : *function_definitions) {
+      const base::DictionaryValue* func_dict = nullptr;
+      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));
-    signatures_[name] = base::MakeUnique<APISignature>(*params);
+      const base::ListValue* params = nullptr;
+      CHECK(func_dict->GetList("parameters", &params));
+      signatures_[name] = base::MakeUnique<APISignature>(*params);
+    }
   }
   if (type_definitions) {
     for (const auto& type : *type_definitions) {
       const base::DictionaryValue* type_dict = nullptr;
       CHECK(type->GetAsDictionary(&type_dict));
       std::string id;
       CHECK(type_dict->GetString("id", &id));
       DCHECK(type_refs->find(id) == type_refs->end());
       // TODO(devlin): refs are sometimes preceeded by the API namespace; we
       // might need to take that into account.
@@ skipping 123 matching lines @@
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   DCHECK(converted_arguments);
   method_callback_.Run(name, std::move(converted_arguments), isolate, context,
                        callback);
 }
 
 }  // namespace extensions