Headless: Remove obsolete Mojo code and some other obsolete APIs

headless/lib/embedder_mojo_browsertest.cc

Index: headless/lib/embedder_mojo_browsertest.cc
diff --git a/headless/lib/embedder_mojo_browsertest.cc b/headless/lib/embedder_mojo_browsertest.cc
deleted file mode 100644
index b05b403c8d81a4d7e67377fff7454b2991df6407..0000000000000000000000000000000000000000
--- a/headless/lib/embedder_mojo_browsertest.cc
+++ /dev/null
@@ -1,262 +0,0 @@
-// 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/optional.h"
-#include "base/path_service.h"
-#include "base/run_loop.h"
-#include "base/strings/string_piece.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/devtools/domains/network.h"
-#include "headless/public/devtools/domains/page.h"
-#include "headless/public/devtools/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 and registers a mojo
-// interface before starting the test.
-class EmbedderMojoTest : public HeadlessBrowserTest,
-                         public HeadlessWebContents::Observer,
-                         public embedder_test::TestEmbedderService {
- public:
-  enum HttpPolicy { DEFAULT, ENABLE_HTTP };
-
-  EmbedderMojoTest() : EmbedderMojoTest(HttpPolicy::DEFAULT) {}
-
-  explicit EmbedderMojoTest(HttpPolicy http_policy)
-      : browser_context_(nullptr),
-        web_contents_(nullptr),
-        devtools_client_(HeadlessDevToolsClient::Create()),
-        http_policy_(http_policy) {}
-
-  ~EmbedderMojoTest() override {}
-
-  void SetUp() override {
-    // Set service names before they are used during main thread initialization.
-    options()->mojo_service_names.insert("embedder_test::TestEmbedderService");
-
-    HeadlessBrowserTest::SetUp();
-  }
-
-  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);
-  }
-
-  // HeadlessWebContents::Observer 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();
-
-    HeadlessBrowserContext::Builder builder =
-        browser()->CreateBrowserContextBuilder();
-    builder.AddJsMojoBindings("headless/lib/embedder_test.mojom",
-                              embedder_test_mojom_js);
-    if (http_policy_ == HttpPolicy::ENABLE_HTTP) {
-      builder.EnableUnsafeNetworkAccessWithMojoBindings(true);
-    }
-    if (host_resolver_rules_) {
-      builder.SetHostResolverRules(*host_resolver_rules_);
-    }
-
-    browser_context_ = builder.Build();
-
-    web_contents_ =
-        browser_context_->CreateWebContentsBuilder()
-            .SetInitialURL(GURL(GetInitialUrl()))
-            .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_->Close();
-    browser_context_ = nullptr;
-  }
-
-  void CreateTestMojoService(
-      mojo::InterfaceRequest<embedder_test::TestEmbedderService> request) {
-    test_embedder_mojo_bindings_.AddBinding(this, std::move(request));
-  }
-
-  HeadlessBrowserContext* browser_context_;
-  HeadlessWebContents* web_contents_;
-  std::unique_ptr<HeadlessDevToolsClient> devtools_client_;
-
-  mojo::BindingSet<embedder_test::TestEmbedderService>
-      test_embedder_mojo_bindings_;
-
-  HttpPolicy http_policy_;
-  base::Optional<std::string> host_resolver_rules_;
-};
-
-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"
-        "    'content/public/renderer/frame_interfaces',                     \n"
-        "    ], function(embedderMojom, frameInterfaces) {                   \n"
-        "  var testEmbedderService =                                         \n"
-        "      new embedderMojom.TestEmbedderServicePtr(                     \n"
-        "          frameInterfaces.getInterface(                             \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 std::string& result) override {
-    EXPECT_EQ("hello world", result);
-    FinishAsynchronousTest();
-  }
-};
-
-DEVTOOLS_CLIENT_TEST_F(MojoBindingsTest);
-
-class MojoBindingsReinstalledAfterNavigation : public EmbedderMojoTest {
- public:
-  MojoBindingsReinstalledAfterNavigation()
-      : EmbedderMojoTest(HttpPolicy::ENABLE_HTTP), 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.
-    host_resolver_rules_ =
-        base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d",
-                           embedded_test_server()->host_port_pair().port());
-
-    EmbedderMojoTest::SetUpOnMainThread();
-  }
-
-  void RunMojoTest() override {}
-
-  GURL GetInitialUrl() const override {
-    return embedded_test_server()->GetURL("/mojo_page_one.html");
-  }
-
-  // embedder_test::TestEmbedderService:
-  void ReturnTestResult(const std::string& result) override {
-    if (result == "page one") {
-      seen_page_one_ = true;
-      devtools_client_->GetPage()->Navigate(
-          "http://not-an-actual-domain.tld/mojo_page_two.html");
-    } else {
-      EXPECT_TRUE(seen_page_one_);
-      EXPECT_EQ("page two", result);
-      FinishAsynchronousTest();
-    }
-  }
-
- private:
-  bool seen_page_one_;
-};
-
-DEVTOOLS_CLIENT_TEST_F(MojoBindingsReinstalledAfterNavigation);
-
-class HttpDisabledByDefaultWhenMojoBindingsUsed : public EmbedderMojoTest,
-                                                  network::Observer,
-                                                  page::Observer {
- public:
-  HttpDisabledByDefaultWhenMojoBindingsUsed() {
-    EXPECT_TRUE(embedded_test_server()->Start());
-  }
-
-  void RunMojoTest() override {
-    base::RunLoop run_loop;
-    devtools_client_->GetNetwork()->AddObserver(this);
-    devtools_client_->GetNetwork()->Enable(run_loop.QuitClosure());
-    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
-        base::MessageLoop::current());
-    run_loop.Run();
-    devtools_client_->GetPage()->AddObserver(this);
-    devtools_client_->GetPage()->Enable();
-    devtools_client_->GetPage()->Navigate(
-        embedded_test_server()->GetURL("/mojo_page_one.html").spec());
-  }
-
-  void ReturnTestResult(const std::string& result) override {
-    DisableClientAndFinishAsynchronousTest();
-    FAIL() << "The HTTP page should not have been served and we should not have"
-              " recieved a mojo callback!";
-  }
-
-  void OnLoadingFailed(const network::LoadingFailedParams& params) override {
-    // The navigation should fail since HTTP requests are blackholed.
-    EXPECT_EQ(params.GetErrorText(), "net::ERR_FILE_NOT_FOUND");
-    DisableClientAndFinishAsynchronousTest();
-  }
-
-  void DisableClientAndFinishAsynchronousTest() {
-    devtools_client_->GetNetwork()->Disable();
-    devtools_client_->GetNetwork()->RemoveObserver(this);
-    FinishAsynchronousTest();
-  }
-};
-
-DEVTOOLS_CLIENT_TEST_F(HttpDisabledByDefaultWhenMojoBindingsUsed);
-
-}  // namespace headless