[Extensions Bindings] Add access checks in custom types

extensions/renderer/content_setting.cc

 // Copyright 2017 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/content_setting.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/public/common/console_message_level.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "extensions/renderer/api_signature.h"
 #include "extensions/renderer/api_type_reference_map.h"
+#include "extensions/renderer/binding_access_checker.h"
 #include "extensions/renderer/console.h"
 #include "extensions/renderer/script_context_set.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 
 namespace extensions {
 
 namespace {
 
 // Content settings that are deprecated.
 const char* const kDeprecatedTypes[] = {
     "fullscreen", "mouselock",
 };
 
 bool IsDeprecated(base::StringPiece type) {
   return std::find(std::begin(kDeprecatedTypes), std::end(kDeprecatedTypes),
                    type) != std::end(kDeprecatedTypes);
 }
 }
 
 v8::Local<v8::Object> ContentSetting::Create(
     const binding::RunJSFunction& run_js,
     v8::Isolate* isolate,
     const std::string& property_name,
     const base::ListValue* property_values,
     APIRequestHandler* request_handler,
     APIEventHandler* event_handler,
-    APITypeReferenceMap* type_refs) {
+    APITypeReferenceMap* type_refs,
+    const BindingAccessChecker* access_checker) {
   std::string pref_name;
   CHECK(property_values->GetString(0u, &pref_name));
   const base::DictionaryValue* value_spec = nullptr;
   CHECK(property_values->GetDictionary(1u, &value_spec));
 
   gin::Handle<ContentSetting> handle = gin::CreateHandle(
-      isolate, new ContentSetting(run_js, request_handler, type_refs, pref_name,
-                                  *value_spec));
+      isolate, new ContentSetting(run_js, request_handler, type_refs,
+                                  access_checker, pref_name, *value_spec));
   return handle.ToV8().As<v8::Object>();
 }
 
 ContentSetting::ContentSetting(const binding::RunJSFunction& run_js,
                                APIRequestHandler* request_handler,
                                const APITypeReferenceMap* type_refs,
+                               const BindingAccessChecker* access_checker,
                                const std::string& pref_name,
                                const base::DictionaryValue& set_value_spec)
     : run_js_(run_js),
       request_handler_(request_handler),
       type_refs_(type_refs),
+      access_checker_(access_checker),
       pref_name_(pref_name),
       argument_spec_(ArgumentType::OBJECT) {
   // The set() call takes an object { setting: { type: <t> }, ... }, where <t>
   // is the custom set() argument specified above by value_spec.
   ArgumentSpec::PropertiesMap properties;
   properties["primaryPattern"] =
       base::MakeUnique<ArgumentSpec>(ArgumentType::STRING);
   {
     auto secondary_pattern_spec =
         base::MakeUnique<ArgumentSpec>(ArgumentType::STRING);
@@ skipping 49 matching lines @@
 
 void ContentSetting::HandleFunction(const std::string& method_name,
                                     gin::Arguments* arguments) {
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = arguments->GetHolderCreationContext();
 
   std::vector<v8::Local<v8::Value>> argument_list = arguments->GetAll();
 
   std::string full_name = "contentSettings.ContentSetting." + method_name;
+
+  if (!access_checker_->HasAccessOrThrowError(context, full_name))
+    return;
+
   std::unique_ptr<base::ListValue> converted_arguments;
   v8::Local<v8::Function> callback;
   std::string error;
   if (!type_refs_->GetTypeMethodSignature(full_name)->ParseArgumentsToJSON(
           context, argument_list, *type_refs_, &converted_arguments, &callback,
           &error)) {
     arguments->ThrowTypeError("Invalid invocation: " + error);
     return;
   }
 
@@ skipping 37 matching lines @@
     }
   }
 
   converted_arguments->Insert(0u, base::MakeUnique<base::Value>(pref_name_));
   request_handler_->StartRequest(
       context, "contentSettings." + method_name, std::move(converted_arguments),
       callback, v8::Local<v8::Function>(), binding::RequestThread::UI);
 }
 
 }  // namespace extensions