| // 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/api_bindings_system.h" |
| |
| #include "base/bind.h" |
| #include "base/macros.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/stl_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/values.h" |
| #include "extensions/common/extension_api.h" |
| #include "extensions/renderer/api_binding.h" |
| #include "extensions/renderer/api_binding_test.h" |
| #include "extensions/renderer/api_binding_test_util.h" |
| #include "gin/converter.h" |
| #include "gin/try_catch.h" |
| |
| namespace extensions { |
| |
| namespace { |
| |
| // Fake API for testing. |
| const char kAlphaAPIName[] = "alpha"; |
| const char kAlphaAPISpec[] = |
| "{" |
| " 'types': [{" |
| " 'id': 'objRef'," |
| " 'type': 'object'," |
| " 'properties': {" |
| " 'prop1': {'type': 'string'}," |
| " 'prop2': {'type': 'integer', 'optional': true}" |
| " }" |
| " }]," |
| " 'functions': [{" |
| " 'name': 'functionWithCallback'," |
| " 'parameters': [{" |
| " 'name': 'str'," |
| " 'type': 'string'" |
| " }, {" |
| " 'name': 'callback'," |
| " 'type': 'function'" |
| " }]" |
| " }, {" |
| " 'name': 'functionWithRefAndCallback'," |
| " 'parameters': [{" |
| " 'name': 'ref'," |
| " '$ref': 'objRef'" |
| " }, {" |
| " 'name': 'callback'," |
| " 'type': 'function'" |
| " }]" |
| " }]," |
| " 'events': [{" |
| " 'name': 'alphaEvent'" |
| " }]" |
| "}"; |
| |
| // Another fake API for testing. |
| const char kBetaAPIName[] = "beta"; |
| const char kBetaAPISpec[] = |
| "{" |
| " 'functions': [{" |
| " 'name': 'simpleFunc'," |
| " 'parameters': [{'name': 'int', 'type': 'integer'}]" |
| " }]" |
| "}"; |
| |
| bool AllowAllAPIs(const std::string& name) { |
| return true; |
| } |
| |
| } // namespace |
| |
| // The base class to test the APIBindingsSystem. This allows subclasses to |
| // retrieve API schemas differently. |
| class APIBindingsSystemTestBase : public APIBindingTest { |
| public: |
| // Returns the DictionaryValue representing the schema with the given API |
| // name. |
| virtual const base::DictionaryValue& GetAPISchema( |
| const std::string& api_name) = 0; |
| |
| // Stores the request in |last_request_|. |
| void OnAPIRequest(std::unique_ptr<APIBindingsSystem::Request> request) { |
| ASSERT_FALSE(last_request_); |
| last_request_ = std::move(request); |
| } |
| |
| protected: |
| APIBindingsSystemTestBase() {} |
| void SetUp() override { |
| APIBindingTest::SetUp(); |
| bindings_system_ = base::MakeUnique<APIBindingsSystem>( |
| base::Bind(&RunFunctionOnGlobalAndIgnoreResult), |
| base::Bind(&APIBindingsSystemTestBase::GetAPISchema, |
| base::Unretained(this)), |
| base::Bind(&APIBindingsSystemTestBase::OnAPIRequest, |
| base::Unretained(this))); |
| } |
| |
| void TearDown() override { |
| bindings_system_.reset(); |
| APIBindingTest::TearDown(); |
| } |
| |
| // Checks that |last_request_| exists and was provided with the |
| // |expected_name| and |expected_arguments|. |
| void ValidateLastRequest(const std::string& expected_name, |
| const std::string& expected_arguments); |
| |
| const APIBindingsSystem::Request* last_request() const { |
| return last_request_.get(); |
| } |
| void reset_last_request() { last_request_.reset(); } |
| APIBindingsSystem* bindings_system() { return bindings_system_.get(); } |
| |
| private: |
| // The APIBindingsSystem associated with the test. Safe to use across multiple |
| // contexts. |
| std::unique_ptr<APIBindingsSystem> bindings_system_; |
| |
| // The last request to be received from the APIBindingsSystem, or null if |
| // there is none. |
| std::unique_ptr<APIBindingsSystem::Request> last_request_; |
| |
| DISALLOW_COPY_AND_ASSIGN(APIBindingsSystemTestBase); |
| }; |
| |
| void APIBindingsSystemTestBase::ValidateLastRequest( |
| const std::string& expected_name, |
| const std::string& expected_arguments) { |
| ASSERT_TRUE(last_request()); |
| // Note that even if no arguments are provided by the API call, we should have |
| // an empty list. |
| ASSERT_TRUE(last_request()->arguments); |
| EXPECT_EQ(expected_name, last_request()->method_name); |
| EXPECT_EQ(ReplaceSingleQuotes(expected_arguments), |
| ValueToString(*last_request()->arguments)); |
| } |
| |
| // An implementation that works with fake/supplied APIs, for easy testability. |
| class APIBindingsSystemTest : public APIBindingsSystemTestBase { |
| protected: |
| APIBindingsSystemTest() {} |
| |
| // Calls a function constructed from |script_source| on the given |object|. |
| void CallFunctionOnObject(v8::Local<v8::Context> context, |
| v8::Local<v8::Object> object, |
| const std::string& script_source); |
| |
| private: |
| const base::DictionaryValue& GetAPISchema( |
| const std::string& api_name) override { |
| EXPECT_TRUE(base::ContainsKey(api_schemas_, api_name)); |
| return *api_schemas_[api_name]; |
| } |
| void SetUp() override; |
| |
| // The API schemas for the fake APIs. |
| std::map<std::string, std::unique_ptr<base::DictionaryValue>> api_schemas_; |
| |
| DISALLOW_COPY_AND_ASSIGN(APIBindingsSystemTest); |
| }; |
| |
| void APIBindingsSystemTest::CallFunctionOnObject( |
| v8::Local<v8::Context> context, |
| v8::Local<v8::Object> object, |
| const std::string& script_source) { |
| std::string wrapped_script_source = |
| base::StringPrintf("(function(obj) { %s })", script_source.c_str()); |
| |
| v8::Local<v8::Function> func = |
| FunctionFromString(context, wrapped_script_source); |
| ASSERT_FALSE(func.IsEmpty()); |
| |
| v8::Local<v8::Value> argv[] = {object}; |
| RunFunction(func, context, 1, argv); |
| } |
| |
| void APIBindingsSystemTest::SetUp() { |
| // Create the fake API schemas. |
| { |
| struct APIData { |
| const char* name; |
| const char* spec; |
| } api_data[] = { |
| {kAlphaAPIName, kAlphaAPISpec}, {kBetaAPIName, kBetaAPISpec}, |
| }; |
| for (const auto& api : api_data) { |
| std::unique_ptr<base::DictionaryValue> api_schema = |
| DictionaryValueFromString(api.spec); |
| ASSERT_TRUE(api_schema); |
| api_schemas_[api.name] = std::move(api_schema); |
| } |
| } |
| |
| APIBindingsSystemTestBase::SetUp(); |
| } |
| |
| // Tests API object initialization, calling a method on the supplied APIs, and |
| // triggering the callback for the request. |
| TEST_F(APIBindingsSystemTest, TestInitializationAndCallbacks) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = ContextLocal(); |
| |
| v8::Local<v8::Object> alpha_api = bindings_system()->CreateAPIInstance( |
| kAlphaAPIName, context, isolate(), base::Bind(&AllowAllAPIs)); |
| ASSERT_FALSE(alpha_api.IsEmpty()); |
| v8::Local<v8::Object> beta_api = bindings_system()->CreateAPIInstance( |
| kBetaAPIName, context, isolate(), base::Bind(&AllowAllAPIs)); |
| ASSERT_FALSE(beta_api.IsEmpty()); |
| |
| { |
| // Test a simple call -> response. |
| const char kTestCall[] = |
| "obj.functionWithCallback('foo', function() {\n" |
| " this.callbackArguments = Array.from(arguments);\n" |
| "});"; |
| CallFunctionOnObject(context, alpha_api, kTestCall); |
| |
| ValidateLastRequest("alpha.functionWithCallback", "['foo']"); |
| |
| const char kResponseArgsJson[] = "['response',1,{'key':42}]"; |
| std::unique_ptr<base::ListValue> expected_args = |
| ListValueFromString(kResponseArgsJson); |
| bindings_system()->CompleteRequest(last_request()->request_id, |
| *expected_args); |
| |
| std::unique_ptr<base::Value> result = GetBaseValuePropertyFromObject( |
| context->Global(), context, "callbackArguments"); |
| ASSERT_TRUE(result); |
| EXPECT_EQ(ReplaceSingleQuotes(kResponseArgsJson), ValueToString(*result)); |
| reset_last_request(); |
| } |
| |
| { |
| // Test a call with references -> response. |
| const char kTestCall[] = |
| "obj.functionWithRefAndCallback({prop1: 'alpha', prop2: 42},\n" |
| " function() {\n" |
| " this.callbackArguments = Array.from(arguments);\n" |
| "});"; |
| |
| CallFunctionOnObject(context, alpha_api, kTestCall); |
| |
| ValidateLastRequest("alpha.functionWithRefAndCallback", |
| "[{'prop1':'alpha','prop2':42}]"); |
| |
| bindings_system()->CompleteRequest(last_request()->request_id, |
| base::ListValue()); |
| |
| std::unique_ptr<base::Value> result = GetBaseValuePropertyFromObject( |
| context->Global(), context, "callbackArguments"); |
| ASSERT_TRUE(result); |
| EXPECT_EQ("[]", ValueToString(*result)); |
| reset_last_request(); |
| } |
| |
| { |
| // Test an event registration -> event occurrence. |
| const char kTestCall[] = |
| "obj.alphaEvent.addListener(function() {\n" |
| " this.eventArguments = Array.from(arguments);\n" |
| "});\n"; |
| CallFunctionOnObject(context, alpha_api, kTestCall); |
| |
| const char kResponseArgsJson[] = "['response',1,{'key':42}]"; |
| std::unique_ptr<base::ListValue> expected_args = |
| ListValueFromString(kResponseArgsJson); |
| bindings_system()->FireEventInContext("alpha.alphaEvent", context, |
| *expected_args); |
| |
| std::unique_ptr<base::Value> result = GetBaseValuePropertyFromObject( |
| context->Global(), context, "eventArguments"); |
| ASSERT_TRUE(result); |
| EXPECT_EQ(ReplaceSingleQuotes(kResponseArgsJson), ValueToString(*result)); |
| } |
| |
| { |
| // Test a call -> response on the second API. |
| const char kTestCall[] = "obj.simpleFunc(2)"; |
| CallFunctionOnObject(context, beta_api, kTestCall); |
| ValidateLastRequest("beta.simpleFunc", "[2]"); |
| EXPECT_TRUE(last_request()->request_id.empty()); |
| reset_last_request(); |
| } |
| } |
| |
| // An implementation using real API schemas. |
| class APIBindingsSystemTestWithRealAPI : public APIBindingsSystemTestBase { |
| protected: |
| APIBindingsSystemTestWithRealAPI() {} |
| |
| // Executes the given |script_source| in |context|, expecting no exceptions. |
| void ExecuteScript(v8::Local<v8::Context> context, |
| const std::string& script_source); |
| |
| // Executes the given |script_source| in |context| and compares a caught |
| // error to |expected_error|. |
| void ExecuteScriptAndExpectError(v8::Local<v8::Context> context, |
| const std::string& script_source, |
| const std::string& expected_error); |
| |
| private: |
| const base::DictionaryValue& GetAPISchema( |
| const std::string& api_name) override { |
| const base::DictionaryValue* schema = |
| ExtensionAPI::GetSharedInstance()->GetSchema(api_name); |
| EXPECT_TRUE(schema); |
| return *schema; |
| } |
| |
| DISALLOW_COPY_AND_ASSIGN(APIBindingsSystemTestWithRealAPI); |
| }; |
| |
| void APIBindingsSystemTestWithRealAPI::ExecuteScript( |
| v8::Local<v8::Context> context, |
| const std::string& script_source) { |
| v8::TryCatch try_catch(isolate()); |
| // V8ValueFromScriptSource runs the source and returns the result; here, we |
| // only care about running the source. |
| V8ValueFromScriptSource(context, script_source); |
| EXPECT_FALSE(try_catch.HasCaught()) |
| << gin::V8ToString(try_catch.Message()->Get()); |
| } |
| |
| void APIBindingsSystemTestWithRealAPI::ExecuteScriptAndExpectError( |
| v8::Local<v8::Context> context, |
| const std::string& script_source, |
| const std::string& expected_error) { |
| v8::TryCatch try_catch(isolate()); |
| V8ValueFromScriptSource(context, script_source); |
| ASSERT_TRUE(try_catch.HasCaught()) << script_source; |
| EXPECT_EQ(expected_error, gin::V8ToString(try_catch.Message()->Get())); |
| } |
| |
| // The following test demonstrates how APIBindingsSystem can be used with "real" |
| // Extension APIs; that is, using the raw Extension API schemas, rather than a |
| // substituted test schema. This is useful to both show how the system is |
| // intended to be used in the future as well as to make sure that it works with |
| // actual APIs. |
| TEST_F(APIBindingsSystemTestWithRealAPI, RealAPIs) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = ContextLocal(); |
| |
| v8::Local<v8::Object> chrome = v8::Object::New(isolate()); |
| { |
| v8::Maybe<bool> res = context->Global()->Set( |
| context, gin::StringToV8(isolate(), "chrome"), chrome); |
| ASSERT_TRUE(res.IsJust()); |
| ASSERT_TRUE(res.FromJust()); |
| } |
| |
| auto add_api_to_chrome = [this, &chrome, |
| &context](const std::string& api_name) { |
| v8::Local<v8::Object> api = bindings_system()->CreateAPIInstance( |
| api_name, context, context->GetIsolate(), base::Bind(&AllowAllAPIs)); |
| ASSERT_FALSE(api.IsEmpty()) << api_name; |
| v8::Maybe<bool> res = chrome->Set( |
| context, gin::StringToV8(context->GetIsolate(), api_name), api); |
| ASSERT_TRUE(res.IsJust()); |
| ASSERT_TRUE(res.FromJust()); |
| }; |
| |
| // Pick two relatively small APIs that don't have any custom bindings (which |
| // aren't supported yet). |
| add_api_to_chrome("idle"); |
| add_api_to_chrome("power"); |
| |
| // Test passing methods. |
| { |
| const char kTestCall[] = "chrome.power.requestKeepAwake('display');"; |
| ExecuteScript(context, kTestCall); |
| ValidateLastRequest("power.requestKeepAwake", "['display']"); |
| EXPECT_TRUE(last_request()->request_id.empty()); |
| reset_last_request(); |
| } |
| |
| { |
| const char kTestCall[] = "chrome.power.releaseKeepAwake()"; |
| ExecuteScript(context, kTestCall); |
| ValidateLastRequest("power.releaseKeepAwake", "[]"); |
| EXPECT_TRUE(last_request()->request_id.empty()); |
| reset_last_request(); |
| } |
| |
| { |
| const char kTestCall[] = "chrome.idle.queryState(30, function() {})"; |
| ExecuteScript(context, kTestCall); |
| ValidateLastRequest("idle.queryState", "[30]"); |
| EXPECT_FALSE(last_request()->request_id.empty()); |
| reset_last_request(); |
| } |
| |
| { |
| const char kTestCall[] = "chrome.idle.setDetectionInterval(30);"; |
| ExecuteScript(context, kTestCall); |
| ValidateLastRequest("idle.setDetectionInterval", "[30]"); |
| EXPECT_TRUE(last_request()->request_id.empty()); |
| reset_last_request(); |
| } |
| |
| // Check catching errors. |
| const char kError[] = "Uncaught TypeError: Invalid invocation"; |
| { |
| // "disp" is not an allowed enum value. |
| const char kTestCall[] = "chrome.power.requestKeepAwake('disp');"; |
| ExecuteScriptAndExpectError(context, kTestCall, kError); |
| EXPECT_FALSE(last_request()); |
| reset_last_request(); // Just to not pollute future results. |
| } |
| |
| { |
| // The queryState() param has a minimum of 15. |
| const char kTestCall[] = "chrome.idle.queryState(10, function() {});"; |
| ExecuteScriptAndExpectError(context, kTestCall, kError); |
| EXPECT_FALSE(last_request()); |
| reset_last_request(); // Just to not pollute future results. |
| } |
| |
| { |
| const char kTestCall[] = |
| "chrome.idle.onStateChanged.addListener(state => {\n" |
| " this.idleState = state;\n" |
| "});\n"; |
| ExecuteScript(context, kTestCall); |
| v8::Local<v8::Value> v8_result = |
| GetPropertyFromObject(context->Global(), context, "idleState"); |
| EXPECT_TRUE(v8_result->IsUndefined()); |
| bindings_system()->FireEventInContext("idle.onStateChanged", context, |
| *ListValueFromString("['active']")); |
| |
| std::unique_ptr<base::Value> result = |
| GetBaseValuePropertyFromObject(context->Global(), context, "idleState"); |
| ASSERT_TRUE(result); |
| EXPECT_EQ("\"active\"", ValueToString(*result)); |
| } |
| } |
| |
| } // namespace extensions |