[Extensions Bindings] Allow schema violations through sendRequest

extensions/renderer/argument_spec.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/argument_spec.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
@@ skipping 131 matching lines @@
 ArgumentSpec::~ArgumentSpec() {}
 
 bool ArgumentSpec::ParseArgument(v8::Local<v8::Context> context,
                                  v8::Local<v8::Value> value,
                                  const APITypeReferenceMap& refs,
                                  std::unique_ptr<base::Value>* out_value,
                                  std::string* error) const {
   if (type_ == ArgumentType::FUNCTION) {
     if (!value->IsFunction())
       return false;
-    // Certain APIs, like webRequest and contextMenus, have functions as
-    // parameters that aren't the callback. We need these included in the
-    // signature for validation purposes, but don't *really* need to serialize
-    // them. Unfortunately, if we don't, validation in the browser fails. For
-    // now, the expectation is that functions are serialized as dictionaries,
-    // to match the content::V8ValueConverter behavior.
-    // TODO(devlin): Change this somehow. We could, for instance, add a
-    // 'validation_only' property to the schema to indicate that a parameter
-    // or property shouldn't be serialized or included in the compiled types.
-    if (out_value)
+
+    if (out_value) {
+      // Certain APIs (contextMenus) have functions as parameters other than the
+      // callback (contextMenus uses it for an onclick listener). Our generated
+      // types have adapted to consider functions "objects" and serialize them
+      // as dictionaries.
+      // TODO(devlin): It'd be awfully nice to get rid of this eccentricity.
       *out_value = base::MakeUnique<base::DictionaryValue>();
+    }
     return true;
   }
 
   if (type_ == ArgumentType::REF) {
     DCHECK(ref_);
     const ArgumentSpec* reference = refs.GetSpec(ref_.value());
     DCHECK(reference) << ref_.value();
     return reference->ParseArgument(context, value, refs, out_value, error);
   }
 
@@ skipping 266 matching lines @@
       return false;
     }
     if (type_ == ArgumentType::BINARY)
       DCHECK_EQ(base::Value::Type::BINARY, converted->GetType());
     *out_value = std::move(converted);
   }
   return true;
 }
 
 }  // namespace extensions