[Extensions Bindings] Fix content settings validation

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"
@@ skipping 91 matching lines @@
       .SetMethod("clear", &ContentSetting::Clear)
       .SetMethod("getResourceIdentifiers",
                  &ContentSetting::GetResourceIdentifiers);
 }
 
 void ContentSetting::Get(gin::Arguments* arguments) {
   HandleFunction("get", arguments);
 }
 
 void ContentSetting::Set(gin::Arguments* arguments) {
-  v8::Isolate* isolate = arguments->isolate();
-  v8::HandleScope handle_scope(isolate);
-  v8::Local<v8::Context> context = arguments->GetHolderCreationContext();
-
-  v8::Local<v8::Value> value = arguments->PeekNext();
-  // The set schema included in the Schema object is generic, since it varies
-  // per-setting. However, this is only ever for a single setting, so we can
-  // enforce the types more thoroughly.
-  std::string error;
-  if (!value.IsEmpty() && !argument_spec_.ParseArgument(
-                              context, value, *type_refs_, nullptr, &error)) {
-    arguments->ThrowTypeError("Invalid invocation");
-    return;
-  }
   HandleFunction("set", arguments);
 }
 
 void ContentSetting::Clear(gin::Arguments* arguments) {
   HandleFunction("clear", arguments);
 }
 
 void ContentSetting::GetResourceIdentifiers(gin::Arguments* arguments) {
   HandleFunction("getResourceIdentifiers", arguments);
 }
 
 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;
   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");
+    arguments->ThrowTypeError("Invalid invocation: " + error);
     return;
   }
 
   if (IsDeprecated(pref_name_)) {
     console::AddMessage(ScriptContextSet::GetContextByV8Context(context),
                         content::CONSOLE_MESSAGE_LEVEL_WARNING,
                         base::StringPrintf("contentSettings.%s is deprecated.",
                                            pref_name_.c_str()));
     // If a callback was provided, call it immediately.
     if (!callback.IsEmpty()) {
       std::vector<v8::Local<v8::Value>> args;
       if (method_name == "get") {
         // Deprecated settings are always set to "allow". Populate the result to
         // avoid breaking extensions.
         v8::Local<v8::Object> object = v8::Object::New(isolate);
         v8::Maybe<bool> result = object->DefineOwnProperty(
             context, gin::StringToSymbol(isolate, "setting"),
             gin::StringToSymbol(isolate, "allow"));
         // Since we just defined this object, DefineOwnProperty() should never
         // fail.
         CHECK(result.ToChecked());
         args.push_back(object);
       }
       run_js_.Run(callback, context, args.size(), args.data());
     }
     return;
   }
 
+  if (method_name == "set") {
+    v8::Local<v8::Value> value = argument_list[0];
+    // The set schema included in the Schema object is generic, since it varies
+    // per-setting. However, this is only ever for a single setting, so we can
+    // enforce the types more thoroughly.
+    // Note: we do this *after* checking if the setting is deprecated, since
+    // this validation will fail for deprecated settings.
+    std::string error;
+    if (!value.IsEmpty() && !argument_spec_.ParseArgument(
+                                context, value, *type_refs_, nullptr, &error)) {
+      arguments->ThrowTypeError("Invalid invocation: " + error);
+      return;
+    }
+  }
+
   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