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

extensions/renderer/api_bindings_system.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_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding_hooks.h"
@@ skipping 27 matching lines @@
     *hooks_interface_out = binding->GetJSHookInterface(context);
   return binding->CreateInstance(
       context, isolate, &event_handler_, is_available);
 }
 
 std::unique_ptr<APIBinding> APIBindingsSystem::CreateNewAPIBinding(
     const std::string& api_name) {
   const base::DictionaryValue& api_schema = get_api_schema_.Run(api_name);
 
   const base::ListValue* function_definitions = nullptr;
-  CHECK(api_schema.GetList("functions", &function_definitions));
+  api_schema.GetList("functions", &function_definitions);
   const base::ListValue* type_definitions = nullptr;
-  // Type definitions might not exist for the given API.
   api_schema.GetList("types", &type_definitions);
   const base::ListValue* event_definitions = nullptr;
   api_schema.GetList("events", &event_definitions);
 
   // Find the hooks for the API. If none exist, an empty set will be created so
   // we can use JS custom bindings.
   // TODO(devlin): Once all legacy custom bindings are converted, we don't have
   // to unconditionally pass in binding hooks.
   std::unique_ptr<APIBindingHooks> hooks;
   auto iter = binding_hooks_.find(api_name);
   if (iter != binding_hooks_.end()) {
     hooks = std::move(iter->second);
     binding_hooks_.erase(iter);
   } else {
     hooks = base::MakeUnique<APIBindingHooks>(call_js_);
   }
 
   return base::MakeUnique<APIBinding>(
-      api_name, *function_definitions, type_definitions, event_definitions,
+      api_name, function_definitions, type_definitions, event_definitions,
       base::Bind(&APIBindingsSystem::OnAPICall, base::Unretained(this)),
       std::move(hooks), &type_reference_map_);
 }
 
 void APIBindingsSystem::CompleteRequest(int request_id,
                                         const base::ListValue& response) {
   request_handler_.CompleteRequest(request_id, response);
 }
 
 void APIBindingsSystem::FireEventInContext(const std::string& event_name,
@@ skipping 25 matching lines @@
   }
   // TODO(devlin): Query and curry user gestures around.
   request->has_user_gesture = false;
   request->arguments = std::move(arguments);
   request->method_name = name;
 
   send_request_.Run(std::move(request), context);
 }
 
 }  // namespace extensions