[Extensions Bindings] Allow for argument validation without conversion

extensions/renderer/argument_spec_unittest.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 "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding_test_util.h"
 #include "extensions/renderer/argument_spec.h"
 #include "gin/converter.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/test/v8_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 class ArgumentSpecUnitTest : public gin::V8Test {
  protected:
   ArgumentSpecUnitTest() {}
   ~ArgumentSpecUnitTest() override {}
   void ExpectSuccess(const ArgumentSpec& spec,
                      const std::string& script_source,
                      const std::string& expected_json_single_quotes) {
-    RunTest(spec, script_source, TestResult::PASS,
+    RunTest(spec, script_source, true, TestResult::PASS,
             ReplaceSingleQuotes(expected_json_single_quotes), std::string());
   }
 
+  void ExpectSuccessWithNoConversion(const ArgumentSpec& spec,
+                                     const std::string& script_source) {
+    RunTest(spec, script_source, false, TestResult::PASS,
+            std::string(), std::string());
+  }
+
   void ExpectFailure(const ArgumentSpec& spec,
                      const std::string& script_source) {
-    RunTest(spec, script_source, TestResult::FAIL, std::string(),
+    RunTest(spec, script_source, true, TestResult::FAIL, std::string(),
+            std::string());
+  }
+
+  void ExpectFailureWithNoConversion(const ArgumentSpec& spec,
+                                     const std::string& script_source) {
+    RunTest(spec, script_source, false, TestResult::FAIL, std::string(),
             std::string());
   }
 
   void ExpectThrow(const ArgumentSpec& spec,
                    const std::string& script_source,
                    const std::string& expected_thrown_message) {
-    RunTest(spec, script_source, TestResult::THROW, std::string(),
+    RunTest(spec, script_source, true, TestResult::THROW, std::string(),
             expected_thrown_message);
   }
 
   void AddTypeRef(const std::string& id, std::unique_ptr<ArgumentSpec> spec) {
     type_refs_[id] = std::move(spec);
   }
 
  private:
   enum class TestResult { PASS, FAIL, THROW, };
 
   void RunTest(const ArgumentSpec& spec,
                const std::string& script_source,
+               bool should_convert,
                TestResult expected_result,
                const std::string& expected_json,
                const std::string& expected_thrown_message);
 
   ArgumentSpec::RefMap type_refs_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentSpecUnitTest);
 };
 
 void ArgumentSpecUnitTest::RunTest(const ArgumentSpec& spec,
                                    const std::string& script_source,
+                                   bool should_convert,
                                    TestResult expected_result,
                                    const std::string& expected_json,
                                    const std::string& expected_thrown_message) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(instance_->isolate());
 
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(instance_->isolate(), context_);
   v8::TryCatch try_catch(isolate);
   v8::Local<v8::Value> val = V8ValueFromScriptSource(context, script_source);
   ASSERT_FALSE(val.IsEmpty()) << script_source;
 
   std::string error;
-  std::unique_ptr<base::Value> out_value =
-      spec.ConvertArgument(context, val, type_refs_, &error);
+  std::unique_ptr<base::Value> out_value;
+  bool did_succeed =
+      spec.ParseArgument(context, val, type_refs_,
+                         should_convert ? &out_value : nullptr, &error);
   bool should_succeed = expected_result == TestResult::PASS;
-  ASSERT_EQ(should_succeed, !!out_value) << script_source << ", " << error;
+  ASSERT_EQ(should_succeed, did_succeed) << script_source << ", " << error;
+  ASSERT_EQ(did_succeed && should_convert, !!out_value);
   bool should_throw = expected_result == TestResult::THROW;
   ASSERT_EQ(should_throw, try_catch.HasCaught()) << script_source;
-  if (should_succeed) {
+  if (should_succeed && should_convert) {
     ASSERT_TRUE(out_value);
     EXPECT_EQ(expected_json, ValueToString(*out_value));
   } else if (should_throw) {
     EXPECT_EQ(expected_thrown_message,
               gin::V8ToString(try_catch.Message()->Get()));
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, Test) {
   {
@@ skipping 119 matching lines @@
         "x = {prop1: 'foo'};\n"
         "Object.defineProperty(\n"
         "    x, 'prop2',\n"
         "    { get: () => { throw new Error('Badness'); } });\n"
         "x;",
         "Uncaught Error: Badness");
   }
 
   {
     const char kFunctionSpec[] = "{ 'type': 'function' }";
-    // We don't allow conversion of functions (converting to a base::Value is
-    // impossible), but we should still be able to parse a function
-    // specification.
     ArgumentSpec spec(*ValueFromString(kFunctionSpec));
-    EXPECT_EQ(ArgumentType::FUNCTION, spec.type());
+    ExpectSuccessWithNoConversion(spec, "(function() {})");
+    ExpectSuccessWithNoConversion(spec, "(function(a, b) { a(); b(); })");
+    ExpectSuccessWithNoConversion(spec, "(function(a, b) { a(); b(); })");
+    ExpectFailureWithNoConversion(spec, "({a: function() {}})");
+    ExpectFailureWithNoConversion(spec, "([function() {}])");
+    ExpectFailureWithNoConversion(spec, "1");
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, TypeRefsTest) {
   const char kObjectType[] =
       "{"
       "  'id': 'refObj',"
       "  'type': 'object',"
       "  'properties': {"
       "    'prop1': {'type': 'string'},"
@@ skipping 73 matching lines @@
     ExpectSuccess(spec, "['alpha']", "['alpha']");
     ExpectSuccess(spec, "['alpha', 'beta']", "['alpha','beta']");
     ExpectSuccess(spec, "({prop1: 'alpha'})", "{'prop1':'alpha'}");
     ExpectFailure(spec, "({prop1: 1})");
     ExpectFailure(spec, "'alpha'");
     ExpectFailure(spec, "42");
   }
 }
 
 }  // namespace extensions