[Extensions Bindings] Consider argument type more in signature parsing

extensions/renderer/bindings/api_signature_unittest.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/bindings/api_signature.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "extensions/renderer/bindings/api_binding_test.h"
 #include "extensions/renderer/bindings/api_binding_test_util.h"
@@ skipping 105 matching lines @@
   return base::MakeUnique<APISignature>(std::move(specs));
 }
 
 std::unique_ptr<APISignature> RefEnum() {
   SpecVector specs;
   specs.push_back(
       ArgumentSpecBuilder(ArgumentType::REF, "enum").SetRef("refEnum").Build());
   return base::MakeUnique<APISignature>(std::move(specs));
 }
 
+std::unique_ptr<APISignature> OptionalObjectAndCallback() {
+  SpecVector specs;
+  specs.push_back(
+      ArgumentSpecBuilder(ArgumentType::OBJECT, "obj")
+          .AddProperty(
+              "prop1",
+              ArgumentSpecBuilder(ArgumentType::INTEGER).MakeOptional().Build())
+          .MakeOptional()
+          .Build());
+  specs.push_back(ArgumentSpecBuilder(ArgumentType::FUNCTION, "callback")
+                      .MakeOptional()
+                      .Build());
+  return base::MakeUnique<APISignature>(std::move(specs));
+}
+
 }  // namespace
 
 class APISignatureTest : public APIBindingTest {
  public:
   APISignatureTest()
       : type_refs_(APITypeReferenceMap::InitializeTypeCallback()) {}
   ~APISignatureTest() override = default;
 
   void SetUp() override {
     APIBindingTest::SetUp();
@@ skipping 159 matching lines @@
     ExpectPass(*signature, "[4, {foo: 'bar'}, function() {}]",
                "[4,{'foo':'bar'},null]", true);
     ExpectPass(*signature, "[4, {foo: 'bar'}]", "[4,{'foo':'bar'},null]",
                false);
     ExpectPass(*signature, "[4, {foo: 'bar'}, {}]", "[4,{'foo':'bar'},{}]",
                false);
     ExpectFailure(*signature, "[4, function() {}]",
                   ArgumentError("any", UnserializableValue()));
     ExpectFailure(*signature, "[4]", MissingRequiredArgument("any"));
   }
+
+  {
+    auto signature = OptionalObjectAndCallback();
+    ExpectPass(*signature, "[{prop1: 1}]", "[{'prop1':1}]", false);
+    ExpectPass(*signature, "[]", "[null]", false);
+    ExpectPass(*signature, "[null]", "[null]", false);
+    ExpectFailure(
+        *signature, "[{prop1: 'str'}]",
+        ArgumentError("obj", PropertyError("prop1", InvalidType(kTypeInteger,
+                                                                kTypeString))));
+    ExpectFailure(
+        *signature, "[{prop1: 'str'}, function() {}]",
+        ArgumentError("obj", PropertyError("prop1", InvalidType(kTypeInteger,
+                                                                kTypeString))));
+  }
 }
 
 TEST_F(APISignatureTest, TypeRefsTest) {
   using namespace api_errors;
 
   v8::HandleScope handle_scope(isolate());
 
   {
     auto signature = RefObj();
     ExpectPass(*signature, "[{prop1: 'foo'}]", "[{'prop1':'foo'}]", false);
@@ skipping 87 matching lines @@
     std::unique_ptr<base::ListValue> parsed;
     EXPECT_TRUE(signature->ConvertArgumentsIgnoringSchema(context, v8_args,
                                                           &parsed, &callback));
     ASSERT_TRUE(parsed);
     EXPECT_EQ(R"([{"not":"a string"}])", ValueToString(*parsed));
     EXPECT_TRUE(callback.IsEmpty());
   }
 }
 
 }  // namespace extensions