// Copyright 2018 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/base64.h"
#include "base/base_paths.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/json/json_reader.h"
#include "base/path_service.h"
#include "base/test/scoped_feature_list.h"
#include "base/threading/thread_restrictions.h"
#include "build/build_config.h"
#include "cc/base/switches.h"
#include "components/viz/common/features.h"
#include "components/viz/common/switches.h"
#include "content/public/common/content_switches.h"
#include "content/public/test/browser_test.h"
#include "headless/public/devtools/domains/runtime.h"
#include "headless/public/headless_browser.h"
#include "headless/public/headless_browser_context.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 "net/test/spawned_test_server/spawned_test_server.h"
#include "services/network/public/cpp/network_switches.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/url_util.h"

namespace headless {

namespace {
static const char kResetResults[] = "reset-results";
static const char kDumpDevToolsProtocol[] = "dump-devtools-protocol";
}  // namespace

class HeadlessProtocolBrowserTest
    : public HeadlessAsyncDevTooledBrowserTest,
      public HeadlessDevToolsClient::RawProtocolListener,
      public runtime::ExperimentalObserver {
 public:
  HeadlessProtocolBrowserTest() {
    embedded_test_server()->ServeFilesFromSourceDirectory(
        "third_party/blink/web_tests/http/tests/inspector-protocol");
    EXPECT_TRUE(embedded_test_server()->Start());
  }

 protected:
  void SetUpCommandLine(base::CommandLine* command_line) override {
    command_line->AppendSwitchASCII(::network::switches::kHostResolverRules,
                                    "MAP *.test 127.0.0.1");
    HeadlessAsyncDevTooledBrowserTest::SetUpCommandLine(command_line);

    // Make sure the navigations spawn new processes. We run test harness
    // in one process (harness.test) and tests in another.
    command_line->AppendSwitch(::switches::kSitePerProcess);
    // TODO(yoichio): This is temporary switch to support chrome internal
    // components migration from the old web APIs.
    // After completion of the migration, we should remove this.
    // See crbug.com/911943 for detail.
    command_line->AppendSwitchASCII("enable-blink-features", "HTMLImports");
  }

 private:
  // HeadlessWebContentsObserver implementation.
  void RunDevTooledTest() override {
    browser_devtools_client_->SetRawProtocolListener(this);
    devtools_client_->GetRuntime()->GetExperimental()->AddObserver(this);
    devtools_client_->GetRuntime()->Enable();
    devtools_client_->GetRuntime()->GetExperimental()->AddBinding(
        headless::runtime::AddBindingParams::Builder()
            .SetName("sendProtocolMessage")
            .Build(),
        base::BindOnce(&HeadlessProtocolBrowserTest::BindingCreated,
                       base::Unretained(this)));
  }

  void BindingCreated(std::unique_ptr<headless::runtime::AddBindingResult>) {
    base::ScopedAllowBlockingForTesting allow_blocking;
    base::FilePath src_dir;
    CHECK(base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
    static const base::FilePath kTestsDirectory(
        FILE_PATH_LITERAL("headless/test/data/protocol"));
    base::FilePath test_path =
        src_dir.Append(kTestsDirectory).AppendASCII(script_name_);
    std::string script;
    if (!base::ReadFileToString(test_path, &script)) {
      ADD_FAILURE() << "Unable to read test at " << test_path;
      FinishTest();
      return;
    }
    GURL test_url = embedded_test_server()->GetURL("harness.test",
                                                   "/protocol/" + script_name_);
    GURL target_url = embedded_test_server()->GetURL(
        "127.0.0.1", "/protocol/" + script_name_);
    GURL page_url = embedded_test_server()->GetURL(
        "harness.test", "/protocol/inspector-protocol-test.html?test=" +
                            test_url.spec() + "&target=" + target_url.spec());
    devtools_client_->GetPage()->Navigate(page_url.spec());
  }

  // runtime::Observer implementation.
  void OnBindingCalled(const runtime::BindingCalledParams& params) override {
    std::string json_message = params.GetPayload();
    std::unique_ptr<base::Value> message =
        base::JSONReader::ReadDeprecated(json_message);
    const base::DictionaryValue* message_dict;
    const base::DictionaryValue* params_dict;
    std::string method;
    int id;
    if (!message || !message->GetAsDictionary(&message_dict) ||
        !message_dict->GetString("method", &method) ||
        !message_dict->GetDictionary("params", &params_dict) ||
        !message_dict->GetInteger("id", &id)) {
      LOG(ERROR) << "Poorly formed message " << json_message;
      FinishTest();
      return;
    }

    if (method != "DONE") {
      if (base::CommandLine::ForCurrentProcess()->HasSwitch(
              kDumpDevToolsProtocol)) {
        LOG(INFO) << "FromJS: " << json_message;
      }
      // Pass unhandled commands onto the inspector.
      browser_devtools_client_->SendRawDevToolsMessage(json_message);
      return;
    }

    std::string test_result;
    message_dict->GetString("result", &test_result);
    static const base::FilePath kTestsDirectory(
        FILE_PATH_LITERAL("headless/test/data/protocol"));

    base::ScopedAllowBlockingForTesting allow_blocking;

    base::FilePath src_dir;
    CHECK(base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
    base::FilePath expectation_path =
        src_dir.Append(kTestsDirectory)
            .AppendASCII(script_name_.substr(0, script_name_.length() - 3) +
                         "-expected.txt");

    if (base::CommandLine::ForCurrentProcess()->HasSwitch(kResetResults)) {
      LOG(INFO) << "Updating expectations at " << expectation_path;
      int result = base::WriteFile(expectation_path, test_result.data(),
                                   static_cast<int>(test_result.size()));
      CHECK(test_result.size() == static_cast<size_t>(result));
    }

    std::string expectation;
    if (!base::ReadFileToString(expectation_path, &expectation)) {
      ADD_FAILURE() << "Unable to read expectations at " << expectation_path;
    }
    EXPECT_EQ(test_result, expectation);
    FinishTest();
  }

  // HeadlessDevToolsClient::RawProtocolListener
  bool OnProtocolMessage(const std::string& json_message,
                         const base::DictionaryValue& parsed_message) override {
    SendMessageToJS(json_message);
    return true;
  }

  void SendMessageToJS(const std::string& message) {
    if (test_finished_)
      return;

    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
            kDumpDevToolsProtocol)) {
      LOG(INFO) << "ToJS: " << message;
    }

    std::string encoded;
    base::Base64Encode(message, &encoded);
    devtools_client_->GetRuntime()->Evaluate("onmessage(atob(\"" + encoded +
                                             "\"))");
  }

  void FinishTest() {
    test_finished_ = true;
    FinishAsynchronousTest();
  }

 protected:
  bool test_finished_ = false;
  std::string test_folder_;
  std::string script_name_;
};

#define HEADLESS_PROTOCOL_TEST(TEST_NAME, SCRIPT_NAME)             \
  IN_PROC_BROWSER_TEST_F(HeadlessProtocolBrowserTest, TEST_NAME) { \
    test_folder_ = "/protocol/";                                   \
    script_name_ = SCRIPT_NAME;                                    \
    RunTest();                                                     \
  }

#define LAYOUT_PROTOCOL_TEST(TEST_NAME, SCRIPT_NAME)               \
  IN_PROC_BROWSER_TEST_F(HeadlessProtocolBrowserTest, TEST_NAME) { \
    test_folder_ = "/";                                            \
    script_name_ = SCRIPT_NAME;                                    \
    RunTest();                                                     \
  }

// Headless-specific tests
HEADLESS_PROTOCOL_TEST(VirtualTimeBasics, "emulation/virtual-time-basics.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeInterrupt,
                       "emulation/virtual-time-interrupt.js")

// Flaky on Linux & Mac. TODO(crbug.com/930717): Re-enable.
#if defined(OS_LINUX) || defined(OS_MACOSX)
#define MAYBE_VirtualTimeCrossProcessNavigation \
  DISABLED_VirtualTimeCrossProcessNavigation
#else
#define MAYBE_VirtualTimeCrossProcessNavigation \
  VirtualTimeCrossProcessNavigation
#endif
HEADLESS_PROTOCOL_TEST(MAYBE_VirtualTimeCrossProcessNavigation,
                       "emulation/virtual-time-cross-process-navigation.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeDetachFrame,
                       "emulation/virtual-time-detach-frame.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeNoBlock404, "emulation/virtual-time-404.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeLocalStorage,
                       "emulation/virtual-time-local-storage.js")
HEADLESS_PROTOCOL_TEST(VirtualTimePendingScript,
                       "emulation/virtual-time-pending-script.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeHtmlImport,
                       "emulation/virtual-time-html-import.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeRedirect,
                       "emulation/virtual-time-redirect.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeSessionStorage,
                       "emulation/virtual-time-session-storage.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeStarvation,
                       "emulation/virtual-time-starvation.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeVideo, "emulation/virtual-time-video.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeErrorLoop,
                       "emulation/virtual-time-error-loop.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeFetchStream,
                       "emulation/virtual-time-fetch-stream.js")
HEADLESS_PROTOCOL_TEST(VirtualTimeDialogWhileLoading,
                       "emulation/virtual-time-dialog-while-loading.js")

// Flaky Test crbug.com/859382
HEADLESS_PROTOCOL_TEST(DISABLED_VirtualTimeHistoryNavigation,
                       "emulation/virtual-time-history-navigation.js")

// http://crbug.com/633321
#if defined(OS_ANDROID)
#define MAYBE_VirtualTimeTimerOrder DISABLED_VirtualTimeTimerOrder
#define MAYBE_VirtualTimeTimerSuspend DISABLED_VirtualTimeTimerSuspend
#else
#define MAYBE_VirtualTimeTimerOrder VirtualTimeTimerOrder
#define MAYBE_VirtualTimeTimerSuspend VirtualTimeTimerSuspend
#endif
HEADLESS_PROTOCOL_TEST(MAYBE_VirtualTimeTimerOrder,
                       "emulation/virtual-time-timer-order.js")
HEADLESS_PROTOCOL_TEST(MAYBE_VirtualTimeTimerSuspend,
                       "emulation/virtual-time-timer-suspended.js")
#undef MAYBE_VirtualTimeTimerOrder
#undef MAYBE_VirtualTimeTimerSuspend

class HeadlessProtocolCompositorBrowserTest
    : public HeadlessProtocolBrowserTest {
 public:
  HeadlessProtocolCompositorBrowserTest() = default;

 private:
  void SetUpCommandLine(base::CommandLine* command_line) override {
    HeadlessProtocolBrowserTest::SetUpCommandLine(command_line);
    // The following switches are recommended for BeginFrameControl required by
    // compositor tests, see https://goo.gl/3zHXhB for details
    static const char* const compositor_switches[] = {
        // We control BeginFrames ourselves and need all compositing stages to
        // run.
        switches::kRunAllCompositorStagesBeforeDraw,
        switches::kDisableNewContentRenderingTimeout,

        // Animtion-only BeginFrames are only supported when updates from the
        // impl-thread are disabled, see go/headless-rendering.
        cc::switches::kDisableThreadedAnimation,
        cc::switches::kDisableCheckerImaging,
        switches::kDisableThreadedScrolling,

        // Ensure that image animations don't resync their animation timestamps
        // when looping back around.
        switches::kDisableImageAnimationResync,
    };

    for (auto* compositor_switch : compositor_switches) {
      command_line->AppendSwitch(compositor_switch);
    }

    // In surface synchronization, child surface IDs are allocated by
    // parents and new CompositorFrames only activate once all their child
    // surfaces exist. In --run-all-compositor-stages-before-draw mode, this
    // means that child surface initialization and resize fully propagates
    // within a single BeginFrame.
    scoped_feature_list_.InitAndEnableFeature(
        features::kEnableSurfaceSynchronization);
  }

 protected:
  base::test::ScopedFeatureList scoped_feature_list_;
};

// BeginFrameControl is not supported on MacOS yet, see: https://cs.chromium.org
// chromium/src/headless/lib/browser/protocol/target_handler.cc?
// rcl=5811aa08e60ba5ac7622f029163213cfbdb682f7&l=32
// TODO(crbug.com/954398): Suite is timeout-flaky on Windows.
#if defined(OS_MACOSX) || defined(OS_WIN)
#define HEADLESS_PROTOCOL_COMPOSITOR_TEST(TEST_NAME, SCRIPT_NAME) \
  IN_PROC_BROWSER_TEST_F(HeadlessProtocolCompositorBrowserTest,   \
                         DISABLED_##TEST_NAME) {                  \
    test_folder_ = "/protocol/";                                  \
    script_name_ = SCRIPT_NAME;                                   \
    RunTest();                                                    \
  }
#else
#define HEADLESS_PROTOCOL_COMPOSITOR_TEST(TEST_NAME, SCRIPT_NAME)            \
  IN_PROC_BROWSER_TEST_F(HeadlessProtocolCompositorBrowserTest, TEST_NAME) { \
    test_folder_ = "/protocol/";                                             \
    script_name_ = SCRIPT_NAME;                                              \
    RunTest();                                                               \
  }
#endif

HEADLESS_PROTOCOL_COMPOSITOR_TEST(CompositorBasicRaf,
                                  "emulation/compositor-basic-raf.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    CompositorImageAnimation,
    "emulation/compositor-image-animation-test.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(CompositorCssAnimation,
                                  "emulation/compositor-css-animation-test.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(VirtualTimeControllerTest,
                                  "helpers/virtual-time-controller-test.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererHelloWorld,
                                  "sanity/renderer-hello-world.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererOverrideTitleJsEnabled,
    "sanity/renderer-override-title-js-enabled.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererOverrideTitleJsDisabled,
    "sanity/renderer-override-title-js-disabled.js")
// TODO(crbug.com/943636): rebaseline and re-enable once
// https://chromium-review.googlesource.com/c/v8/v8/+/1593307 is rolled into
// chromium.
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    DISABLED_RendererJavaScriptConsoleErrors,
    "sanity/renderer-javascript-console-errors.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererDelayedCompletion,
                                  "sanity/renderer-delayed-completion.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererClientRedirectChain,
                                  "sanity/renderer-client-redirect-chain.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererClientRedirectChainNoJs,
    "sanity/renderer-client-redirect-chain-no-js.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererServerRedirectChain,
                                  "sanity/renderer-server-redirect-chain.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererServerRedirectToFailure,
    "sanity/renderer-server-redirect-to-failure.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererServerRedirectRelativeChain,
    "sanity/renderer-server-redirect-relative-chain.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererMixedRedirectChain,
                                  "sanity/renderer-mixed-redirect-chain.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererFramesRedirectChain,
                                  "sanity/renderer-frames-redirect-chain.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererDoubleRedirect,
                                  "sanity/renderer-double-redirect.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererRedirectAfterCompletion,
    "sanity/renderer-redirect-after-completion.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirect307PostMethod,
                                  "sanity/renderer-redirect-307-post-method.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectPostChain,
                                  "sanity/renderer-redirect-post-chain.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirect307PutMethod,
                                  "sanity/renderer-redirect-307-put-method.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirect303PutGet,
                                  "sanity/renderer-redirect-303-put-get.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectBaseUrl,
                                  "sanity/renderer-redirect-base-url.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectNonAsciiUrl,
                                  "sanity/renderer-redirect-non-ascii-url.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectEmptyUrl,
                                  "sanity/renderer-redirect-empty-url.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectInvalidUrl,
                                  "sanity/renderer-redirect-invalid-url.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectKeepsFragment,
                                  "sanity/renderer-redirect-keeps-fragment.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererRedirectReplacesFragment,
    "sanity/renderer-redirect-replaces-fragment.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererRedirectNewFragment,
                                  "sanity/renderer-redirect-new-fragment.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererWindowLocationFragments,
    "sanity/renderer-window-location-fragments.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererCookieSetFromJs,
                                  "sanity/renderer-cookie-set-from-js.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(
    RendererCookieSetFromJsNoCookies,
    "sanity/renderer-cookie-set-from-js-no-cookies.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererCookieUpdatedFromJs,
                                  "sanity/renderer-cookie-updated-from-js.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererInCrossOriginObject,
                                  "sanity/renderer-in-cross-origin-object.js")

HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererContentSecurityPolicy,
                                  "sanity/renderer-content-security-policy.js")

HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererFrameLoadEvents,
                                  "sanity/renderer-frame-load-events.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererCssUrlFilter,
                                  "sanity/renderer-css-url-filter.js")
HEADLESS_PROTOCOL_COMPOSITOR_TEST(RendererCanvas, "sanity/renderer-canvas.js")

}  // namespace headless