Index: headless/lib/embedder_mojo_browsertest.cc |
diff --git a/headless/lib/embedder_mojo_browsertest.cc b/headless/lib/embedder_mojo_browsertest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..d748b3150cd235de4f128c6d39c72c6f1af6eb47 |
--- /dev/null |
+++ b/headless/lib/embedder_mojo_browsertest.cc |
@@ -0,0 +1,278 @@ |
+// 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 <memory> |
+#include "base/path_service.h" |
+#include "base/threading/thread_restrictions.h" |
+#include "content/public/test/browser_test.h" |
+#include "headless/grit/headless_browsertest_resources.h" |
+#include "headless/lib/embedder_test.mojom.h" |
+#include "headless/public/domains/runtime.h" |
+#include "headless/public/headless_browser.h" |
+#include "headless/public/headless_devtools_client.h" |
+#include "headless/public/headless_devtools_target.h" |
+#include "headless/public/headless_web_contents.h" |
+#include "headless/test/headless_browser_test.h" |
+#include "mojo/public/cpp/bindings/binding_set.h" |
+#include "mojo/public/cpp/bindings/interface_ptr_set.h" |
+#include "mojo/public/cpp/bindings/interface_request.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "ui/base/resource/resource_bundle.h" |
+#include "url/gurl.h" |
+ |
+namespace headless { |
+ |
+#define DEVTOOLS_CLIENT_TEST_F(TEST_FIXTURE_NAME) \ |
+ IN_PROC_BROWSER_TEST_F(TEST_FIXTURE_NAME, RunAsyncTest) { RunTest(); } \ |
+ class AsyncHeadlessBrowserTestNeedsSemicolon##TEST_FIXTURE_NAME {} |
+ |
+// A test fixture which attaches a devtools client before starting the test. |
+class EmbedderMojoTest : public HeadlessBrowserTest, |
+ public HeadlessWebContents::Observer, |
+ public embedder_test::TestEmbedderService { |
+ public: |
+ EmbedderMojoTest() |
+ : web_contents_(nullptr), |
+ devtools_client_(HeadlessDevToolsClient::Create()) {} |
+ ~EmbedderMojoTest() override {} |
+ |
+ void SetUpOnMainThread() override { |
+ base::ThreadRestrictions::SetIOAllowed(true); |
+ base::FilePath pak_path; |
+ ASSERT_TRUE(PathService::Get(base::DIR_MODULE, &pak_path)); |
+ pak_path = pak_path.AppendASCII("headless_browser_tests.pak"); |
+ ResourceBundle::GetSharedInstance().AddDataPackFromPath( |
+ pak_path, ui::SCALE_FACTOR_NONE); |
+ } |
+ |
+ // HeadlessWebContentsObserver implementation: |
+ void DevToolsTargetReady() override { |
+ EXPECT_TRUE(web_contents_->GetDevToolsTarget()); |
+ web_contents_->GetDevToolsTarget()->AttachClient(devtools_client_.get()); |
+ |
+ RunMojoTest(); |
+ } |
+ |
+ virtual void RunMojoTest() = 0; |
+ |
+ virtual GURL GetInitialUrl() const { return GURL("about:blank"); } |
+ |
+ void OnEvalResult(std::unique_ptr<runtime::EvaluateResult> result) { |
+ EXPECT_FALSE(result->HasExceptionDetails()) |
+ << "JS exception: " << result->GetExceptionDetails()->GetText(); |
+ if (result->HasExceptionDetails()) { |
+ FinishAsynchronousTest(); |
+ } |
+ } |
+ |
+ protected: |
+ void RunTest() { |
+ // Using a pak file is idomatic chromium style, but most embedders probably |
+ // wouln't load the javascript bindings file this way. |
+ std::string embedder_test_mojom_js = |
+ ResourceBundle::GetSharedInstance() |
+ .GetRawDataResource(IDR_HEADLESS_EMBEDDER_TEST_MOJOM_JS) |
+ .as_string(); |
+ |
+ web_contents_ = |
+ browser() |
+ ->CreateWebContentsBuilder() |
+ .SetInitialURL(GURL(GetInitialUrl())) |
+ .AddMojoService(base::Bind(&EmbedderMojoTest::CreateTestMojoService, |
+ base::Unretained(this))) |
+ .AddJsMojoBindings("headless/lib/embedder_test.mojom", |
+ embedder_test_mojom_js) |
+ .Build(); |
+ |
+ web_contents_->AddObserver(this); |
+ RunAsynchronousTest(); |
+ |
+ web_contents_->GetDevToolsTarget()->DetachClient(devtools_client_.get()); |
+ web_contents_->RemoveObserver(this); |
+ web_contents_->Close(); |
+ web_contents_ = nullptr; |
+ } |
+ |
+ void CreateTestMojoService( |
+ mojo::InterfaceRequest<embedder_test::TestEmbedderService> request) { |
+ test_embedder_mojo_bindings_.AddBinding(this, std::move(request)); |
+ } |
+ |
+ HeadlessWebContents* web_contents_; |
+ std::unique_ptr<HeadlessDevToolsClient> devtools_client_; |
+ |
+ mojo::BindingSet<embedder_test::TestEmbedderService> |
+ test_embedder_mojo_bindings_; |
+}; |
+ |
+class EmbedderMojoBindingsTest : public EmbedderMojoTest { |
+ public: |
+ void RunMojoTest() override { |
+ devtools_client_->GetRuntime()->Evaluate( |
+ R"( |
+ mojo.services.embedder_test.TestEmbedderService.then(function(service) { |
+ service.returnTestResult("hello world"); |
+ }); )", |
+ base::Bind(&EmbedderMojoTest::OnEvalResult, base::Unretained(this))); |
+ } |
+ |
+ // embedder_test::TestEmbedderService: |
+ void ReturnTestResult(const mojo::String& result) override { |
+ EXPECT_EQ("hello world", result.get()); |
+ FinishAsynchronousTest(); |
+ } |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(EmbedderMojoBindingsTest); |
+ |
+class RejectNonExistentBindingsTest : public EmbedderMojoTest { |
+ public: |
+ void RunMojoTest() override { |
+ devtools_client_->GetRuntime()->Evaluate( |
+ R"( |
+ mojo.services.embedder_test.TestEmbedderService.then(function(service) { |
+ mojo.services.nonExistent.MojoService.then(function() { |
+ service.returnTestResult("Fail - promise not rejected"); |
+ }).catch(function() { |
+ service.returnTestResult("Pass - promise rejected"); |
+ }); |
+ }); )", |
+ base::Bind(&EmbedderMojoTest::OnEvalResult, base::Unretained(this))); |
+ } |
+ |
+ // embedder_test::TestEmbedderService: |
+ void ReturnTestResult(const mojo::String& result) override { |
+ EXPECT_EQ("Pass - promise rejected", result.get()); |
+ FinishAsynchronousTest(); |
+ } |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(RejectNonExistentBindingsTest); |
+ |
+// Test bindings that occur after the onload event, which is after the browser |
+// has sent us the bindings. |
+class DelayedRejectNonExistentBindingsTest : public EmbedderMojoTest { |
+ public: |
+ DelayedRejectNonExistentBindingsTest() { |
+ EXPECT_TRUE(embedded_test_server()->Start()); |
+ } |
+ |
+ GURL GetInitialUrl() const override { |
+ return embedded_test_server()->GetURL( |
+ "/late_nonexistent_mojo_binding.html"); |
+ } |
+ |
+ void RunMojoTest() override {} |
+ |
+ // embedder_test::TestEmbedderService: |
+ void ReturnTestResult(const mojo::String& result) override { |
+ EXPECT_EQ("Pass - promise rejected", result.get()); |
+ FinishAsynchronousTest(); |
+ } |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(DelayedRejectNonExistentBindingsTest); |
+ |
+class HeadScriptEmbedderMojoBindingsTest : public EmbedderMojoTest { |
+ public: |
+ HeadScriptEmbedderMojoBindingsTest() { |
+ EXPECT_TRUE(embedded_test_server()->Start()); |
+ } |
+ |
+ void RunMojoTest() override {} |
+ |
+ GURL GetInitialUrl() const override { |
+ return embedded_test_server()->GetURL("/mojo_test.html"); |
+ } |
+ |
+ // embedder_test::TestEmbedderService: |
+ void ReturnTestResult(const mojo::String& result) override { |
+ EXPECT_EQ("hello world", result.get()); |
+ FinishAsynchronousTest(); |
+ } |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(HeadScriptEmbedderMojoBindingsTest); |
+ |
+class DefaultMojoStyleBindingsTest : public EmbedderMojoTest { |
+ public: |
+ void RunMojoTest() override { |
+ devtools_client_->GetRuntime()->Evaluate( |
+ R"( |
+ // Note define() defines a module in the mojo module dependency |
+ // system. While we don't expose our module, the callback below only |
+ // fires after the requested modules have been loaded. |
+ define([ |
+ "headless/lib/embedder_test.mojom", |
+ "mojo/public/js/core", |
+ "mojo/public/js/router", |
+ "content/public/renderer/frame_service_registry", |
+ ], function(embedderMojom, mojoCore, routerModule, |
+ serviceProvider) { |
+ var testEmbedderService = |
+ new embedderMojom.TestEmbedderService.proxyClass( |
+ new routerModule.Router( |
+ serviceProvider.connectToService( |
+ embedderMojom.TestEmbedderService.name))); |
+ |
+ // Send a message to the embedder! |
+ testEmbedderService.returnTestResult("hello world"); |
+ }); )", |
+ base::Bind(&EmbedderMojoTest::OnEvalResult, base::Unretained(this))); |
+ } |
+ |
+ // embedder_test::TestEmbedderService: |
+ void ReturnTestResult(const mojo::String& result) override { |
+ EXPECT_EQ("hello world", result.get()); |
+ FinishAsynchronousTest(); |
+ } |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(DefaultMojoStyleBindingsTest); |
+ |
+class AssignToMojoServicesProxyNotAllowed : public EmbedderMojoTest { |
+ public: |
+ void RunMojoTest() override { |
+ devtools_client_->GetRuntime()->Evaluate( |
+ "mojo.services.foo = 'bar';", |
+ base::Bind(&AssignToMojoServicesProxyNotAllowed::OnEvalResult, |
+ base::Unretained(this))); |
+ } |
+ |
+ void OnEvalResult(std::unique_ptr<runtime::EvaluateResult> result) { |
+ ASSERT_TRUE(result->HasExceptionDetails()); |
+ EXPECT_EQ( |
+ "Uncaught Error: Assignment to the mojo services proxy is not allowed", |
+ result->GetExceptionDetails()->GetText()); |
+ FinishAsynchronousTest(); |
+ } |
+ |
+ void ReturnTestResult(const mojo::String& result) override {} |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(AssignToMojoServicesProxyNotAllowed); |
+ |
+class AssignToMojoServicesSecondaryProxyNotAllowed : public EmbedderMojoTest { |
+ public: |
+ void RunMojoTest() override { |
+ devtools_client_->GetRuntime()->Evaluate( |
+ "mojo.services.foo.bar = 'baz';", |
+ base::Bind(&AssignToMojoServicesSecondaryProxyNotAllowed::OnEvalResult, |
+ base::Unretained(this))); |
+ } |
+ |
+ void OnEvalResult(std::unique_ptr<runtime::EvaluateResult> result) { |
+ ASSERT_TRUE(result->HasExceptionDetails()); |
+ EXPECT_EQ( |
+ "Uncaught Error: Assignment to the mojo services proxy is not allowed", |
+ result->GetExceptionDetails()->GetText()); |
+ FinishAsynchronousTest(); |
+ } |
+ |
+ void ReturnTestResult(const mojo::String& result) override {} |
+}; |
+ |
+DEVTOOLS_CLIENT_TEST_F(AssignToMojoServicesSecondaryProxyNotAllowed); |
+ |
+} // namespace headless |