Adds support for headless chrome embedder mojo services

headless/lib/embedder_mojo_browsertest.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 <memory>
+#include "base/path_service.h"
+#include "base/strings/stringprintf.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/domains/page.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.

[Sami, 2016/06/27 11:10:42]

and registers mojo interfaces?

[alex clarke (OOO till 29th), 2016/06/27 11:35:52]

Done.

+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 idiomatic 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();
+
+    browser_context_ =
+        browser()
+            ->CreateBrowserContextBuilder()
+            .AddJsMojoBindings("headless/lib/embedder_test.mojom",
+                               embedder_test_mojom_js)
+            .Build();
+
+    web_contents_ =
+        browser()
+            ->CreateWebContentsBuilder()
+            .SetInitialURL(GURL(GetInitialUrl()))
+            .SetBrowserContext(browser_context_.get())
+            .AddMojoService(base::Bind(&EmbedderMojoTest::CreateTestMojoService,
+                                       base::Unretained(this)))
+            .Build();
+
+    web_contents_->AddObserver(this);
+    RunAsynchronousTest();
+
+    web_contents_->GetDevToolsTarget()->DetachClient(devtools_client_.get());
+    web_contents_->RemoveObserver(this);
+    web_contents_->Close();
+    web_contents_ = nullptr;
+
+    browser_context_.reset();
+  }
+
+  void CreateTestMojoService(
+      mojo::InterfaceRequest<embedder_test::TestEmbedderService> request) {
+    test_embedder_mojo_bindings_.AddBinding(this, std::move(request));
+  }
+
+  std::unique_ptr<HeadlessBrowserContext> browser_context_;
+  HeadlessWebContents* web_contents_;
+  std::unique_ptr<HeadlessDevToolsClient> devtools_client_;
+
+  mojo::BindingSet<embedder_test::TestEmbedderService>
+      test_embedder_mojo_bindings_;
+};
+
+class MojoBindingsTest : public EmbedderMojoTest {
+ public:
+  void RunMojoTest() override {
+    devtools_client_->GetRuntime()->Evaluate(
+        "// Note define() defines a module in the mojo module dependency     \n"
+        "// system. While we don't expose our module, the callback below only\n"
+        "// fires after the requested modules have been loaded.              \n"
+        "define([                                                            \n"
+        "    'headless/lib/embedder_test.mojom',                             \n"
+        "    'mojo/public/js/core',                                          \n"
+        "    'mojo/public/js/router',                                        \n"
+        "    'content/public/renderer/frame_service_registry',               \n"
+        "    ], function(embedderMojom, mojoCore, routerModule,              \n"
+        "                serviceProvider) {                                  \n"
+        "  var testEmbedderService =                                         \n"
+        "      new embedderMojom.TestEmbedderService.proxyClass(             \n"
+        "          new routerModule.Router(                                  \n"
+        "              serviceProvider.connectToService(                     \n"
+        "                  embedderMojom.TestEmbedderService.name)));        \n"
+        "                                                                    \n"
+        "  // Send a message to the embedder!                                \n"
+        "  testEmbedderService.returnTestResult('hello world');              \n"
+        "});",
+        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(MojoBindingsTest);
+
+class MojoBindingsReinstalledAfterNavigation : public EmbedderMojoTest {
+ public:
+  MojoBindingsReinstalledAfterNavigation() : seen_page_one_(false) {
+    EXPECT_TRUE(embedded_test_server()->Start());
+  }
+
+  void SetUpOnMainThread() override {
+    // We want to make sure bindings work across browser initiated cross-origin
+    // navigation, which is why we're setting up this fake tld.
+    HeadlessBrowser::Options::Builder builder;
+    builder.SetHostResolverRules(
+        base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d",
+                           embedded_test_server()->host_port_pair().port()));
+    SetBrowserOptions(builder.Build());
+
+    EmbedderMojoTest::SetUpOnMainThread();
+  }
+
+  void RunMojoTest() override {}
+
+  GURL GetInitialUrl() const override {
+    return embedded_test_server()->GetURL("/page_one.html");
+  }
+
+  // embedder_test::TestEmbedderService:
+  void ReturnTestResult(const mojo::String& result) override {
+    if (result.get() == "page one") {
+      seen_page_one_ = true;
+      devtools_client_->GetPage()->Navigate(
+          "http://not-an-actual-domain.tld/page_two.html");
+    } else {
+      EXPECT_TRUE(seen_page_one_);
+      EXPECT_EQ("page two", result.get());
+      FinishAsynchronousTest();
+    }
+  }
+
+ private:
+  bool seen_page_one_;
+};
+
+DEVTOOLS_CLIENT_TEST_F(MojoBindingsReinstalledAfterNavigation);
+
+}  // namespace headless