extensions/renderer/api_binding_unittest.cc - chromium/src.git - Git at Google

 // 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/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding.h"
 #include "extensions/renderer/api_binding_test.h"
 #include "extensions/renderer/api_binding_test_util.h"
 #include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "gin/converter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"

 namespace extensions {

 namespace {

 // Function spec; we use single quotes for readability and then replace them.
 const char kFunctions[] =
     "[{"
     "  'name': 'oneString',"
     "  'parameters': [{"
     "    'type': 'string',"
     "    'name': 'str'"
     "   }]"
     "}, {"
     "  'name': 'stringAndInt',"
     "  'parameters': [{"
     "    'type': 'string',"
     "    'name': 'str'"
     "   }, {"
     "     'type': 'integer',"
     "     'name': 'int'"
     "   }]"
     "}, {"
     "  'name': 'stringOptionalIntAndBool',"
     "  'parameters': [{"
     "    'type': 'string',"
     "    'name': 'str'"
     "   }, {"
     "     'type': 'integer',"
     "     'name': 'optionalint',"
     "     'optional': true"
     "   }, {"
     "     'type': 'boolean',"
     "     'name': 'bool'"
     "   }]"
     "}, {"
     "  'name': 'oneObject',"
     "  'parameters': [{"
     "    'type': 'object',"
     "    'name': 'foo',"
     "    'properties': {"
     "      'prop1': {'type': 'string'},"
     "      'prop2': {'type': 'string', 'optional': true}"
     "    }"
     "  }]"
     "}, {"
     "  'name': 'noArgs',"
     "  'parameters': []"
     "}, {"
     "  'name': 'intAndCallback',"
     "  'parameters': [{"
     "    'name': 'int',"
     "    'type': 'integer'"
     "  }, {"
     "    'name': 'callback',"
     "    'type': 'function'"
     "  }]"
     "}, {"
     "  'name': 'optionalIntAndCallback',"
     "  'parameters': [{"
     "    'name': 'int',"
     "    'type': 'integer',"
     "    'optional': true"
     "  }, {"
     "    'name': 'callback',"
     "    'type': 'function'"
     "  }]"
     "}, {"
     "  'name': 'optionalCallback',"
     "  'parameters': [{"
     "    'name': 'callback',"
     "    'type': 'function',"
     "    'optional': true"
     "  }]"
     "}]";

 const char kError[] = "Uncaught TypeError: Invalid invocation";

 bool AllowAllAPIs(const std::string& name) {
   return true;
 }

 }  // namespace

 class APIBindingUnittest : public APIBindingTest {
  public:
   void OnFunctionCall(const std::string& name,
                       std::unique_ptr<base::ListValue> arguments,
                       v8::Isolate* isolate,
                       v8::Local<v8::Context> context,
                       v8::Local<v8::Function> callback) {
     last_request_id_.clear();
     arguments_ = std::move(arguments);
     if (!callback.IsEmpty()) {
       last_request_id_ =
           request_handler_->AddPendingRequest(isolate, callback, context);
     }
   }

  protected:
   APIBindingUnittest() {}
   void SetUp() override {
     APIBindingTest::SetUp();
     request_handler_ = base::MakeUnique<APIRequestHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   }

   void TearDown() override {
     request_handler_.reset();
     APIBindingTest::TearDown();
   }

   void ExpectPass(v8::Local<v8::Object> object,
                   const std::string& script_source,
                   const std::string& expected_json_arguments_single_quotes) {
     RunTest(object, script_source, true,
             ReplaceSingleQuotes(expected_json_arguments_single_quotes),
             std::string());
   }

   void ExpectFailure(v8::Local<v8::Object> object,
                      const std::string& script_source,
                      const std::string& expected_error) {
     RunTest(object, script_source, false, std::string(), expected_error);
   }

   const std::string& last_request_id() const { return last_request_id_; }
   APIRequestHandler* request_handler() { return request_handler_.get(); }

  private:
   void RunTest(v8::Local<v8::Object> object,
                const std::string& script_source,
                bool should_pass,
                const std::string& expected_json_arguments,
                const std::string& expected_error);

   std::unique_ptr<base::ListValue> arguments_;
   std::unique_ptr<APIRequestHandler> request_handler_;
   std::string last_request_id_;

   DISALLOW_COPY_AND_ASSIGN(APIBindingUnittest);
 };

 void APIBindingUnittest::RunTest(v8::Local<v8::Object> object,
                                  const std::string& script_source,
                                  bool should_pass,
                                  const std::string& expected_json_arguments,
                                  const std::string& expected_error) {
   EXPECT_FALSE(arguments_);
   std::string wrapped_script_source =
       base::StringPrintf("(function(obj) { %s })", script_source.c_str());

   v8::Local<v8::Context> context = ContextLocal();
   v8::Local<v8::Function> func =
       FunctionFromString(context, wrapped_script_source);
   ASSERT_FALSE(func.IsEmpty());

   v8::Local<v8::Value> argv[] = {object};

   if (should_pass) {
     RunFunction(func, context, 1, argv);
     ASSERT_TRUE(arguments_) << script_source;
     EXPECT_EQ(expected_json_arguments, ValueToString(*arguments_));
   } else {
     RunFunctionAndExpectError(func, context, 1, argv, expected_error);
     EXPECT_FALSE(arguments_);
   }

   arguments_.reset();
 }

 TEST_F(APIBindingUnittest, Test) {
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       &refs);
   EXPECT_TRUE(refs.empty());

   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();

   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));

   ExpectPass(binding_object, "obj.oneString('foo');", "['foo']");
   ExpectPass(binding_object, "obj.oneString('');", "['']");
   ExpectFailure(binding_object, "obj.oneString(1);", kError);
   ExpectFailure(binding_object, "obj.oneString();", kError);
   ExpectFailure(binding_object, "obj.oneString({});", kError);
   ExpectFailure(binding_object, "obj.oneString('foo', 'bar');", kError);

   ExpectPass(binding_object, "obj.stringAndInt('foo', 42);", "['foo',42]");
   ExpectPass(binding_object, "obj.stringAndInt('foo', -1);", "['foo',-1]");
   ExpectFailure(binding_object, "obj.stringAndInt(1);", kError);
   ExpectFailure(binding_object, "obj.stringAndInt('foo');", kError);
   ExpectFailure(binding_object, "obj.stringAndInt(1, 'foo');", kError);
   ExpectFailure(binding_object, "obj.stringAndInt('foo', 'foo');", kError);
   ExpectFailure(binding_object, "obj.stringAndInt('foo', '1');", kError);
   ExpectFailure(binding_object, "obj.stringAndInt('foo', 2.3);", kError);

   ExpectPass(binding_object, "obj.stringOptionalIntAndBool('foo', 42, true);",
              "['foo',42,true]");
   ExpectPass(binding_object, "obj.stringOptionalIntAndBool('foo', true);",
              "['foo',null,true]");
   ExpectFailure(binding_object,
                 "obj.stringOptionalIntAndBool('foo', 'bar', true);", kError);

   ExpectPass(binding_object,
              "obj.oneObject({prop1: 'foo'});", "[{'prop1':'foo'}]");
   ExpectFailure(
       binding_object,
       "obj.oneObject({ get prop1() { throw new Error('Badness'); } });",
       "Uncaught Error: Badness");

   ExpectPass(binding_object, "obj.noArgs()", "[]");
   ExpectFailure(binding_object, "obj.noArgs(0)", kError);
   ExpectFailure(binding_object, "obj.noArgs('')", kError);
   ExpectFailure(binding_object, "obj.noArgs(null)", kError);
   ExpectFailure(binding_object, "obj.noArgs(undefined)", kError);

   ExpectPass(binding_object, "obj.intAndCallback(1, function() {})", "[1]");
   ExpectFailure(binding_object, "obj.intAndCallback(function() {})", kError);
   ExpectFailure(binding_object, "obj.intAndCallback(1)", kError);

   ExpectPass(binding_object, "obj.optionalIntAndCallback(1, function() {})",
              "[1]");
   ExpectPass(binding_object, "obj.optionalIntAndCallback(function() {})",
              "[null]");
   ExpectFailure(binding_object, "obj.optionalIntAndCallback(1)", kError);

   ExpectPass(binding_object, "obj.optionalCallback(function() {})", "[]");
   ExpectPass(binding_object, "obj.optionalCallback()", "[]");
   ExpectPass(binding_object, "obj.optionalCallback(undefined)", "[]");
   ExpectFailure(binding_object, "obj.optionalCallback(0)", kError);
 }

 TEST_F(APIBindingUnittest, TypeRefsTest) {
   const char kTypes[] =
       "[{"
       "  'id': 'refObj',"
       "  'type': 'object',"
       "  'properties': {"
       "    'prop1': {'type': 'string'},"
       "    'prop2': {'type': 'integer', 'optional': true}"
       "  }"
       "}, {"
       "  'id': 'refEnum',"
       "  'type': 'string',"
       "  'enum': ['alpha', 'beta']"
       "}]";
   const char kRefFunctions[] =
       "[{"
       "  'name': 'takesRefObj',"
       "  'parameters': [{"
       "    'name': 'o',"
       "    '$ref': 'refObj'"
       "  }]"
       "}, {"
       "  'name': 'takesRefEnum',"
       "  'parameters': [{"
       "    'name': 'e',"
       "    '$ref': 'refEnum'"
       "   }]"
       "}]";

   std::unique_ptr<base::ListValue> functions =
       ListValueFromString(kRefFunctions);
   ASSERT_TRUE(functions);
   std::unique_ptr<base::ListValue> types = ListValueFromString(kTypes);
   ASSERT_TRUE(types);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, types.get(), nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       &refs);
   EXPECT_EQ(2u, refs.size());
   EXPECT_TRUE(base::ContainsKey(refs, "refObj"));
   EXPECT_TRUE(base::ContainsKey(refs, "refEnum"));

   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();

   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));

   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo'})",
              "[{'prop1':'foo'}]");
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 2})",
              "[{'prop1':'foo','prop2':2}]");
   ExpectFailure(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
                 kError);
   ExpectPass(binding_object, "obj.takesRefEnum('alpha')", "['alpha']");
   ExpectPass(binding_object, "obj.takesRefEnum('beta')", "['beta']");
   ExpectFailure(binding_object, "obj.takesRefEnum('gamma')", kError);
 }

 TEST_F(APIBindingUnittest, RestrictedAPIs) {
   const char kRestrictedFunctions[] =
       "[{"
       "  'name': 'allowedOne',"
       "  'parameters': []"
       "}, {"
       "  'name': 'allowedTwo',"
       "  'parameters': []"
       "}, {"
       "  'name': 'restrictedOne',"
       "  'parameters': []"
       "}, {"
       "  'name': 'restrictedTwo',"
       "  'parameters': []"
       "}]";
   std::unique_ptr<base::ListValue> functions =
       ListValueFromString(kRestrictedFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       &refs);

   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();

   auto is_available = [](const std::string& name) {
     std::set<std::string> functions = {"test.allowedOne", "test.allowedTwo",
                                        "test.restrictedOne",
                                        "test.restrictedTwo"};
     EXPECT_TRUE(functions.count(name));
     return name == "test.allowedOne" || name == "test.allowedTwo";
   };

   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(is_available));

   auto is_defined = [&binding_object, context](const std::string& name) {
     v8::Local<v8::Value> val =
         GetPropertyFromObject(binding_object, context, name);
     EXPECT_FALSE(val.IsEmpty());
     return !val->IsUndefined() && !val->IsNull();
   };

   EXPECT_TRUE(is_defined("allowedOne"));
   EXPECT_TRUE(is_defined("allowedTwo"));
   EXPECT_FALSE(is_defined("restrictedOne"));
   EXPECT_FALSE(is_defined("restrictedTwo"));
 }

 // Tests that events specified in the API are created as properties of the API
 // object.
 TEST_F(APIBindingUnittest, TestEventCreation) {
   const char kEvents[] = "[{'name': 'onFoo'}, {'name': 'onBar'}]";
   std::unique_ptr<base::ListValue> events = ListValueFromString(kEvents);
   ASSERT_TRUE(events);
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, events.get(),
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       &refs);

   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();

   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));

   // Event behavior is tested in the APIEventHandler unittests as well as the
   // APIBindingsSystem tests, so we really only need to check that the events
   // are being initialized on the object.
   v8::Maybe<bool> has_on_foo =
       binding_object->Has(context, gin::StringToV8(isolate(), "onFoo"));
   EXPECT_TRUE(has_on_foo.IsJust());
   EXPECT_TRUE(has_on_foo.FromJust());

   v8::Maybe<bool> has_on_bar =
       binding_object->Has(context, gin::StringToV8(isolate(), "onBar"));
   EXPECT_TRUE(has_on_bar.IsJust());
   EXPECT_TRUE(has_on_bar.FromJust());

   v8::Maybe<bool> has_on_baz =
       binding_object->Has(context, gin::StringToV8(isolate(), "onBaz"));
   EXPECT_TRUE(has_on_baz.IsJust());
   EXPECT_FALSE(has_on_baz.FromJust());
 }

 }  // namespace extensions
	// 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/bind.h"
	#include "base/memory/ptr_util.h"
	#include "base/stl_util.h"
	#include "base/strings/stringprintf.h"
	#include "base/values.h"
	#include "extensions/renderer/api_binding.h"
	#include "extensions/renderer/api_binding_test.h"
	#include "extensions/renderer/api_binding_test_util.h"
	#include "extensions/renderer/api_event_handler.h"
	#include "extensions/renderer/api_request_handler.h"
	#include "gin/converter.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "v8/include/v8.h"

	namespace extensions {

	namespace {

	// Function spec; we use single quotes for readability and then replace them.
	const char kFunctions[] =
	"[{"
	" 'name': 'oneString',"
	" 'parameters': [{"
	" 'type': 'string',"
	" 'name': 'str'"
	" }]"
	"}, {"
	" 'name': 'stringAndInt',"
	" 'parameters': [{"
	" 'type': 'string',"
	" 'name': 'str'"
	" }, {"
	" 'type': 'integer',"
	" 'name': 'int'"
	" }]"
	"}, {"
	" 'name': 'stringOptionalIntAndBool',"
	" 'parameters': [{"
	" 'type': 'string',"
	" 'name': 'str'"
	" }, {"
	" 'type': 'integer',"
	" 'name': 'optionalint',"
	" 'optional': true"
	" }, {"
	" 'type': 'boolean',"
	" 'name': 'bool'"
	" }]"
	"}, {"
	" 'name': 'oneObject',"
	" 'parameters': [{"
	" 'type': 'object',"
	" 'name': 'foo',"
	" 'properties': {"
	" 'prop1': {'type': 'string'},"
	" 'prop2': {'type': 'string', 'optional': true}"
	" }"
	" }]"
	"}, {"
	" 'name': 'noArgs',"
	" 'parameters': []"
	"}, {"
	" 'name': 'intAndCallback',"
	" 'parameters': [{"
	" 'name': 'int',"
	" 'type': 'integer'"
	" }, {"
	" 'name': 'callback',"
	" 'type': 'function'"
	" }]"
	"}, {"
	" 'name': 'optionalIntAndCallback',"
	" 'parameters': [{"
	" 'name': 'int',"
	" 'type': 'integer',"
	" 'optional': true"
	" }, {"
	" 'name': 'callback',"
	" 'type': 'function'"
	" }]"
	"}, {"
	" 'name': 'optionalCallback',"
	" 'parameters': [{"
	" 'name': 'callback',"
	" 'type': 'function',"
	" 'optional': true"
	" }]"
	"}]";

	const char kError[] = "Uncaught TypeError: Invalid invocation";

	bool AllowAllAPIs(const std::string& name) {
	return true;
	}

	} // namespace

	class APIBindingUnittest : public APIBindingTest {
	public:
	void OnFunctionCall(const std::string& name,
	std::unique_ptr<base::ListValue> arguments,
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	v8::Local<v8::Function> callback) {
	last_request_id_.clear();
	arguments_ = std::move(arguments);
	if (!callback.IsEmpty()) {
	last_request_id_ =
	request_handler_->AddPendingRequest(isolate, callback, context);
	}
	}

	protected:
	APIBindingUnittest() {}
	void SetUp() override {
	APIBindingTest::SetUp();
	request_handler_ = base::MakeUnique<APIRequestHandler>(
	base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
	}

	void TearDown() override {
	request_handler_.reset();
	APIBindingTest::TearDown();
	}

	void ExpectPass(v8::Local<v8::Object> object,
	const std::string& script_source,
	const std::string& expected_json_arguments_single_quotes) {
	RunTest(object, script_source, true,
	ReplaceSingleQuotes(expected_json_arguments_single_quotes),
	std::string());
	}

	void ExpectFailure(v8::Local<v8::Object> object,
	const std::string& script_source,
	const std::string& expected_error) {
	RunTest(object, script_source, false, std::string(), expected_error);
	}

	const std::string& last_request_id() const { return last_request_id_; }
	APIRequestHandler* request_handler() { return request_handler_.get(); }

	private:
	void RunTest(v8::Local<v8::Object> object,
	const std::string& script_source,
	bool should_pass,
	const std::string& expected_json_arguments,
	const std::string& expected_error);

	std::unique_ptr<base::ListValue> arguments_;
	std::unique_ptr<APIRequestHandler> request_handler_;
	std::string last_request_id_;

	DISALLOW_COPY_AND_ASSIGN(APIBindingUnittest);
	};

	void APIBindingUnittest::RunTest(v8::Local<v8::Object> object,
	const std::string& script_source,
	bool should_pass,
	const std::string& expected_json_arguments,
	const std::string& expected_error) {
	EXPECT_FALSE(arguments_);
	std::string wrapped_script_source =
	base::StringPrintf("(function(obj) { %s })", script_source.c_str());

	v8::Local<v8::Context> context = ContextLocal();
	v8::Local<v8::Function> func =
	FunctionFromString(context, wrapped_script_source);
	ASSERT_FALSE(func.IsEmpty());

	v8::Local<v8::Value> argv[] = {object};

	if (should_pass) {
	RunFunction(func, context, 1, argv);
	ASSERT_TRUE(arguments_) << script_source;
	EXPECT_EQ(expected_json_arguments, ValueToString(*arguments_));
	} else {
	RunFunctionAndExpectError(func, context, 1, argv, expected_error);
	EXPECT_FALSE(arguments_);
	}

	arguments_.reset();
	}

	TEST_F(APIBindingUnittest, Test) {
	std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
	ASSERT_TRUE(functions);
	ArgumentSpec::RefMap refs;
	APIBinding binding(
	"test", *functions, nullptr, nullptr,
	base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
	&refs);
	EXPECT_TRUE(refs.empty());

	v8::HandleScope handle_scope(isolate());
	v8::Local<v8::Context> context = ContextLocal();

	APIEventHandler event_handler(
	base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
	v8::Local<v8::Object> binding_object = binding.CreateInstance(
	context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));

	ExpectPass(binding_object, "obj.oneString('foo');", "['foo']");
	ExpectPass(binding_object, "obj.oneString('');", "['']");
	ExpectFailure(binding_object, "obj.oneString(1);", kError);
	ExpectFailure(binding_object, "obj.oneString();", kError);
	ExpectFailure(binding_object, "obj.oneString({});", kError);
	ExpectFailure(binding_object, "obj.oneString('foo', 'bar');", kError);

	ExpectPass(binding_object, "obj.stringAndInt('foo', 42);", "['foo',42]");
	ExpectPass(binding_object, "obj.stringAndInt('foo', -1);", "['foo',-1]");
	ExpectFailure(binding_object, "obj.stringAndInt(1);", kError);
	ExpectFailure(binding_object, "obj.stringAndInt('foo');", kError);
	ExpectFailure(binding_object, "obj.stringAndInt(1, 'foo');", kError);
	ExpectFailure(binding_object, "obj.stringAndInt('foo', 'foo');", kError);
	ExpectFailure(binding_object, "obj.stringAndInt('foo', '1');", kError);
	ExpectFailure(binding_object, "obj.stringAndInt('foo', 2.3);", kError);

	ExpectPass(binding_object, "obj.stringOptionalIntAndBool('foo', 42, true);",
	"['foo',42,true]");
	ExpectPass(binding_object, "obj.stringOptionalIntAndBool('foo', true);",
	"['foo',null,true]");
	ExpectFailure(binding_object,
	"obj.stringOptionalIntAndBool('foo', 'bar', true);", kError);

	ExpectPass(binding_object,
	"obj.oneObject({prop1: 'foo'});", "[{'prop1':'foo'}]");
	ExpectFailure(
	binding_object,
	"obj.oneObject({ get prop1() { throw new Error('Badness'); } });",
	"Uncaught Error: Badness");

	ExpectPass(binding_object, "obj.noArgs()", "[]");
	ExpectFailure(binding_object, "obj.noArgs(0)", kError);
	ExpectFailure(binding_object, "obj.noArgs('')", kError);
	ExpectFailure(binding_object, "obj.noArgs(null)", kError);
	ExpectFailure(binding_object, "obj.noArgs(undefined)", kError);

	ExpectPass(binding_object, "obj.intAndCallback(1, function() {})", "[1]");
	ExpectFailure(binding_object, "obj.intAndCallback(function() {})", kError);
	ExpectFailure(binding_object, "obj.intAndCallback(1)", kError);

	ExpectPass(binding_object, "obj.optionalIntAndCallback(1, function() {})",
	"[1]");
	ExpectPass(binding_object, "obj.optionalIntAndCallback(function() {})",
	"[null]");
	ExpectFailure(binding_object, "obj.optionalIntAndCallback(1)", kError);

	ExpectPass(binding_object, "obj.optionalCallback(function() {})", "[]");
	ExpectPass(binding_object, "obj.optionalCallback()", "[]");
	ExpectPass(binding_object, "obj.optionalCallback(undefined)", "[]");
	ExpectFailure(binding_object, "obj.optionalCallback(0)", kError);
	}

	TEST_F(APIBindingUnittest, TypeRefsTest) {
	const char kTypes[] =
	"[{"
	" 'id': 'refObj',"
	" 'type': 'object',"
	" 'properties': {"
	" 'prop1': {'type': 'string'},"
	" 'prop2': {'type': 'integer', 'optional': true}"
	" }"
	"}, {"
	" 'id': 'refEnum',"
	" 'type': 'string',"
	" 'enum': ['alpha', 'beta']"
	"}]";
	const char kRefFunctions[] =
	"[{"
	" 'name': 'takesRefObj',"
	" 'parameters': [{"
	" 'name': 'o',"
	" '$ref': 'refObj'"
	" }]"
	"}, {"
	" 'name': 'takesRefEnum',"
	" 'parameters': [{"
	" 'name': 'e',"
	" '$ref': 'refEnum'"
	" }]"
	"}]";

	std::unique_ptr<base::ListValue> functions =
	ListValueFromString(kRefFunctions);
	ASSERT_TRUE(functions);
	std::unique_ptr<base::ListValue> types = ListValueFromString(kTypes);
	ASSERT_TRUE(types);
	ArgumentSpec::RefMap refs;
	APIBinding binding(
	"test", *functions, types.get(), nullptr,
	base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
	&refs);
	EXPECT_EQ(2u, refs.size());
	EXPECT_TRUE(base::ContainsKey(refs, "refObj"));
	EXPECT_TRUE(base::ContainsKey(refs, "refEnum"));

	v8::HandleScope handle_scope(isolate());
	v8::Local<v8::Context> context = ContextLocal();

	APIEventHandler event_handler(
	base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
	v8::Local<v8::Object> binding_object = binding.CreateInstance(
	context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));

	ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo'})",
	"[{'prop1':'foo'}]");
	ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 2})",
	"[{'prop1':'foo','prop2':2}]");
	ExpectFailure(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
	kError);
	ExpectPass(binding_object, "obj.takesRefEnum('alpha')", "['alpha']");
	ExpectPass(binding_object, "obj.takesRefEnum('beta')", "['beta']");
	ExpectFailure(binding_object, "obj.takesRefEnum('gamma')", kError);
	}

	TEST_F(APIBindingUnittest, RestrictedAPIs) {
	const char kRestrictedFunctions[] =
	"[{"
	" 'name': 'allowedOne',"
	" 'parameters': []"
	"}, {"
	" 'name': 'allowedTwo',"
	" 'parameters': []"
	"}, {"
	" 'name': 'restrictedOne',"
	" 'parameters': []"
	"}, {"
	" 'name': 'restrictedTwo',"
	" 'parameters': []"
	"}]";
	std::unique_ptr<base::ListValue> functions =
	ListValueFromString(kRestrictedFunctions);
	ASSERT_TRUE(functions);
	ArgumentSpec::RefMap refs;
	APIBinding binding(
	"test", *functions, nullptr, nullptr,
	base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
	&refs);

	v8::HandleScope handle_scope(isolate());
	v8::Local<v8::Context> context = ContextLocal();

	auto is_available = [](const std::string& name) {
	std::set<std::string> functions = {"test.allowedOne", "test.allowedTwo",
	"test.restrictedOne",
	"test.restrictedTwo"};
	EXPECT_TRUE(functions.count(name));
	return name == "test.allowedOne" \|\| name == "test.allowedTwo";
	};

	APIEventHandler event_handler(
	base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
	v8::Local<v8::Object> binding_object = binding.CreateInstance(
	context, isolate(), &event_handler, base::Bind(is_available));

	auto is_defined = [&binding_object, context](const std::string& name) {
	v8::Local<v8::Value> val =
	GetPropertyFromObject(binding_object, context, name);
	EXPECT_FALSE(val.IsEmpty());
	return !val->IsUndefined() && !val->IsNull();
	};

	EXPECT_TRUE(is_defined("allowedOne"));
	EXPECT_TRUE(is_defined("allowedTwo"));
	EXPECT_FALSE(is_defined("restrictedOne"));
	EXPECT_FALSE(is_defined("restrictedTwo"));
	}

	// Tests that events specified in the API are created as properties of the API
	// object.
	TEST_F(APIBindingUnittest, TestEventCreation) {
	const char kEvents[] = "[{'name': 'onFoo'}, {'name': 'onBar'}]";
	std::unique_ptr<base::ListValue> events = ListValueFromString(kEvents);
	ASSERT_TRUE(events);
	std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
	ASSERT_TRUE(functions);
	ArgumentSpec::RefMap refs;
	APIBinding binding(
	"test", *functions, nullptr, events.get(),
	base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
	&refs);

	v8::HandleScope handle_scope(isolate());
	v8::Local<v8::Context> context = ContextLocal();

	APIEventHandler event_handler(
	base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
	v8::Local<v8::Object> binding_object = binding.CreateInstance(
	context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));

	// Event behavior is tested in the APIEventHandler unittests as well as the
	// APIBindingsSystem tests, so we really only need to check that the events
	// are being initialized on the object.
	v8::Maybe<bool> has_on_foo =
	binding_object->Has(context, gin::StringToV8(isolate(), "onFoo"));
	EXPECT_TRUE(has_on_foo.IsJust());
	EXPECT_TRUE(has_on_foo.FromJust());

	v8::Maybe<bool> has_on_bar =
	binding_object->Has(context, gin::StringToV8(isolate(), "onBar"));
	EXPECT_TRUE(has_on_bar.IsJust());
	EXPECT_TRUE(has_on_bar.FromJust());

	v8::Maybe<bool> has_on_baz =
	binding_object->Has(context, gin::StringToV8(isolate(), "onBaz"));
	EXPECT_TRUE(has_on_baz.IsJust());
	EXPECT_FALSE(has_on_baz.FromJust());
	}

	} // namespace extensions