[Extensions Bindings] Handle updating context permissions

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"
 
 namespace extensions {
 
 APIBindingsSystem::APIBindingsSystem(
     const binding::RunJSFunction& call_js,
     const binding::RunJSFunctionSync& call_js_sync,
     const GetAPISchemaMethod& get_api_schema,
+    const APIBinding::AvailabilityCallback& is_available,
     const APIRequestHandler::SendRequestMethod& send_request,
     const APIEventHandler::EventListenersChangedMethod& event_listeners_changed,
     APILastError last_error)
     : type_reference_map_(base::Bind(&APIBindingsSystem::InitializeType,
                                      base::Unretained(this))),
       request_handler_(send_request, call_js, std::move(last_error)),
       event_handler_(call_js, event_listeners_changed),
       call_js_(call_js),
       call_js_sync_(call_js_sync),
-      get_api_schema_(get_api_schema) {}
+      get_api_schema_(get_api_schema),
+      is_available_(is_available) {}
 
 APIBindingsSystem::~APIBindingsSystem() {}
 
 v8::Local<v8::Object> APIBindingsSystem::CreateAPIInstance(
     const std::string& api_name,
     v8::Local<v8::Context> context,
-    const APIBinding::AvailabilityCallback& is_available,
     APIBindingHooks** hooks_out) {
   std::unique_ptr<APIBinding>& binding = api_bindings_[api_name];
   if (!binding)
     binding = CreateNewAPIBinding(api_name);
   if (hooks_out)
     *hooks_out = binding->hooks();
-  return binding->CreateInstance(context, is_available);
+  return binding->CreateInstance(context);
 }
 
 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;
   api_schema.GetList("functions", &function_definitions);
   const base::ListValue* type_definitions = nullptr;
   api_schema.GetList("types", &type_definitions);
@@ skipping 12 matching lines @@
     hooks = std::move(iter->second);
     binding_hooks_.erase(iter);
   } else {
     hooks = base::MakeUnique<APIBindingHooks>(api_name, call_js_sync_);
   }
 
   return base::MakeUnique<APIBinding>(
       api_name, function_definitions, type_definitions, event_definitions,
       property_definitions,
       base::Bind(&APIBindingsSystem::CreateCustomType, base::Unretained(this)),
-      std::move(hooks), &type_reference_map_, &request_handler_,
+      is_available_, std::move(hooks), &type_reference_map_, &request_handler_,
       &event_handler_);
 }
 
 void APIBindingsSystem::InitializeType(const std::string& type_name) {
   // In order to initialize the type, we just initialize the full binding. This
   // seems like a lot of work, but in practice, trying to extract out only the
   // types from the schema, and then update the reference map based on that, is
   // close enough to the same cost. Additionally, this happens lazily on API
   // use, and relatively few APIs specify types from another API. Finally, this
   // will also go away if/when we generate all these specifications.
@@ skipping 50 matching lines @@
     const std::string& property_name,
     const base::ListValue* property_values) {
   auto iter = custom_types_.find(type_name);
   DCHECK(iter != custom_types_.end()) << "Custom type not found: " << type_name;
   return iter->second.Run(isolate, property_name, property_values,
                           &request_handler_, &event_handler_,
                           &type_reference_map_);
 }
 
 }  // namespace extensions