// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/dev_ui/android/dev_ui_loader_throttle.h"

#include <deque>
#include <memory>
#include <utility>

#include "chrome/android/modules/dev_ui/provider/dev_ui_module_provider.h"
#include "chrome/test/base/chrome_render_view_host_test_harness.h"
#include "content/public/browser/navigation_handle.h"
#include "content/public/test/mock_navigation_handle.h"
#include "content/public/test/mock_navigation_throttle_registry.h"
#include "net/base/net_errors.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/features.h"
#include "url/gurl.h"

namespace dev_ui {

namespace {

const char* const kNonDevUiUrls[] = {
    "https://example.com",
    "https://example.com/path?query#frag",
    "chrome://credits",
    "chrome://credits/path?query#frag",
};

const char* const kDevUiUrls[] = {
    "chrome://bluetooth-internals",
    "chrome://bluetooth-internals/path?query#frag",
};

/******** MockDevUiModuleProvider ********/

// Mock DevUiModuleProvider that overrides the main module install / load
// functions, and provides SimulateAsyncInstall().
class MockDevUiModuleProvider : public DevUiModuleProvider {
 public:
  MockDevUiModuleProvider() = default;
  ~MockDevUiModuleProvider() override = default;

  // DevUiModuleProvider:
  bool ModuleInstalled() override { return is_installed_; }

  // DevUiModuleProvider:
  void InstallModule(base::OnceCallback<void(bool)> on_complete) override {
    on_complete_queue_.emplace_back(std::move(on_complete));
  }

  // DevUiModuleProvider:
  void EnsureLoaded() override { is_loaded_ = true; }

  void Reset() {
    is_installed_ = false;
    is_loaded_ = false;
    on_complete_queue_.clear();
  }

  // Simulate DevUI DFN install, and dispatches all on-complete callbacks.
  void SimulateAsyncInstall(bool install_succeeds) {
    is_installed_ = is_installed_ || install_succeeds;
    while (!on_complete_queue_.empty()) {
      std::move(on_complete_queue_.front()).Run(install_succeeds);
      on_complete_queue_.pop_front();
    }
  }

  // Direct access of fake installation states.
  void SetIsInstalled(bool is_installed) { is_installed_ = is_installed; }
  bool GetIsInstalled() const { return is_installed_; }
  void SetIsLoaded(bool is_loaded) { is_loaded_ = is_loaded; }
  bool GetIsLoaded() const { return is_loaded_; }

 private:
  bool is_installed_ = false;
  bool is_loaded_ = false;
  std::deque<base::OnceCallback<void(bool)>> on_complete_queue_;
};

/******** TestDevUiLoaderThrottle ********/

// DevUiLoaderThrottle that overrides and captures Resume() and
// CancelDeferredNavigation(). This is needed because:
// * In actual usage, both functions can lead to throttle deletion, which is
//   problematic since the tests own the throttle instance.
// * We want to record results for verification.
// Note that this is instantiated directly, instead of using
// DevUiLoaderThrottle::MaybeCreateAndAdd().
class TestDevUiLoaderThrottle : public DevUiLoaderThrottle {
 public:
  explicit TestDevUiLoaderThrottle(
      content::NavigationThrottleRegistry& registry)
      : DevUiLoaderThrottle(registry), cancel_result(LAST) {}
  ~TestDevUiLoaderThrottle() override = default;
  TestDevUiLoaderThrottle(const TestDevUiLoaderThrottle&) = delete;
  const TestDevUiLoaderThrottle& operator=(const TestDevUiLoaderThrottle&) =
      delete;

  // content::NavigationThrottle:
  void Resume() override { called_resume = true; }

  // content::NavigationThrottle:
  void CancelDeferredNavigation(
      content::NavigationThrottle::ThrottleCheckResult result) override {
    called_cancel = true;
    cancel_result = std::move(result);
  }

  bool called_resume = false;
  bool called_cancel = false;
  content::NavigationThrottle::ThrottleCheckResult cancel_result;
};

/******** DevUiLoaderThrottleTest ********/

class DevUiLoaderThrottleTest : public ChromeRenderViewHostTestHarness {
 public:
  DevUiLoaderThrottleTest() = default;
  ~DevUiLoaderThrottleTest() override = default;
  DevUiLoaderThrottleTest(const DevUiLoaderThrottleTest&) = delete;
  const DevUiLoaderThrottleTest& operator=(const DevUiLoaderThrottleTest&) =
      delete;

  void SetUp() override {
    ChromeRenderViewHostTestHarness::SetUp();
    DevUiModuleProvider::SetTestInstance(&mock_provider_);
  }

  void TearDown() override {
    mock_provider_.Reset();
    DevUiModuleProvider::SetTestInstance(nullptr);
    ChromeRenderViewHostTestHarness::TearDown();
  }

 protected:
  MockDevUiModuleProvider mock_provider_;
};

class DevUiLoaderThrottleFencedFrameTest : public DevUiLoaderThrottleTest {
 public:
  DevUiLoaderThrottleFencedFrameTest() {
    scoped_feature_list_.InitAndEnableFeatureWithParameters(
        blink::features::kFencedFrames, {{"implementation_type", "mparch"}});
  }

 private:
  base::test::ScopedFeatureList scoped_feature_list_;
};

}  // namespace

TEST_F(DevUiLoaderThrottleTest, ShouldInstallDevUiDfm) {
  auto ShouldInstallDevUiDfm = DevUiLoaderThrottle::ShouldInstallDevUiDfm;
  for (const char* url_string : kNonDevUiUrls) {
    EXPECT_FALSE(ShouldInstallDevUiDfm(GURL(url_string)));
  }
  for (const char* url_string : kDevUiUrls) {
    EXPECT_TRUE(ShouldInstallDevUiDfm(GURL(url_string)));
  }
}

// Test to ensure that pages that are purposefully left in the base module are
// not accidentally moved to the DevUI DFM.
TEST_F(DevUiLoaderThrottleTest, PreventAccidentalInclusion) {
  auto ShouldInstallDevUiDfm = DevUiLoaderThrottle::ShouldInstallDevUiDfm;

  // Useful to have the catalog always.
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://chrome-urls")));
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://about")));
  // Inclusion in base module is mandatory.
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://credits")));
  // Well-loved game, and shown when there's no internet (cannot install DFM).
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://dino")));
  // chrome://flags has relatively high usage.
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://flags")));
  // Useful for filing bugs.
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://version")));
  // Used by Android WebView.
  EXPECT_FALSE(ShouldInstallDevUiDfm(GURL("chrome://safe-browsing")));
}

TEST_F(DevUiLoaderThrottleTest, MaybeCreateAndAdd) {
  bool is_installed = false;
  auto creates_throttle = [&](const std::string& url_string) -> bool {
    mock_provider_.Reset();
    mock_provider_.SetIsInstalled(is_installed);
    content::MockNavigationHandle handle(GURL(url_string), main_rfh());
    content::MockNavigationThrottleRegistry registry(
        &handle,
        content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
    DevUiLoaderThrottle::MaybeCreateAndAdd(registry);
    return !registry.throttles().empty();
  };

  // Case 1: DevUI DFM is not installed.
  is_installed = false;
  // Case 1a: Non DevUI URLs: Throttle not created.
  for (const char* url_string : kNonDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }
  // Case 1b: DevUI URLs: Throttle created, but no load takes place.
  for (const char* url_string : kDevUiUrls) {
    EXPECT_TRUE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }

  // Case 2: DevUI DFM is installed.
  is_installed = true;
  // Case 2a: Non DevUI URLs: Throttle not created.
  for (const char* url_string : kNonDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }
  // Case 2b: DevUI URLs: Throttle not created, but load takes place.
  for (const char* url_string : kDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_TRUE(mock_provider_.GetIsLoaded());
  }
}

TEST_F(DevUiLoaderThrottleFencedFrameTest, MaybeCreateAndAdd) {
  bool is_installed = false;
  content::RenderFrameHost* render_frame_host = nullptr;
  auto creates_throttle = [&](const std::string& url_string) -> bool {
    mock_provider_.Reset();
    mock_provider_.SetIsInstalled(is_installed);
    content::MockNavigationHandle handle(GURL(url_string), render_frame_host);
    content::MockNavigationThrottleRegistry registry(
        &handle,
        content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
    DevUiLoaderThrottle::MaybeCreateAndAdd(registry);
    return !registry.throttles().empty();
  };

  content::RenderFrameHostTester::For(main_rfh())
      ->InitializeRenderFrameIfNeeded();
  render_frame_host =
      content::RenderFrameHostTester::For(main_rfh())->AppendFencedFrame();
  EXPECT_TRUE(render_frame_host);

  // In any case, throttles should not be created in fenced frames.
  is_installed = false;
  for (const char* url_string : kNonDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }
  for (const char* url_string : kDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }
  is_installed = true;
  for (const char* url_string : kNonDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }
  for (const char* url_string : kDevUiUrls) {
    EXPECT_FALSE(creates_throttle(url_string));
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
  }
}

TEST_F(DevUiLoaderThrottleTest, InstallSuccess) {
  for (const char* url_string : kDevUiUrls) {
    mock_provider_.Reset();
    content::MockNavigationHandle handle(GURL(url_string), main_rfh());
    content::MockNavigationThrottleRegistry registry(
        &handle,
        content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
    auto throttle = std::make_unique<TestDevUiLoaderThrottle>(registry);
    EXPECT_FALSE(throttle->called_resume);
    EXPECT_FALSE(throttle->called_cancel);
    EXPECT_FALSE(mock_provider_.GetIsInstalled());
    EXPECT_FALSE(mock_provider_.GetIsLoaded());

    // Simulate request start.
    EXPECT_EQ(content::NavigationThrottle::DEFER, throttle->WillStartRequest());
    EXPECT_FALSE(throttle->called_resume);
    EXPECT_FALSE(throttle->called_cancel);
    EXPECT_FALSE(mock_provider_.GetIsInstalled());
    EXPECT_FALSE(mock_provider_.GetIsLoaded());

    // Simulate actual install (success)
    mock_provider_.SimulateAsyncInstall(true);  // !
    EXPECT_TRUE(throttle->called_resume);
    EXPECT_FALSE(throttle->called_cancel);
    EXPECT_TRUE(mock_provider_.GetIsInstalled());
    EXPECT_TRUE(mock_provider_.GetIsLoaded());
  }
}

TEST_F(DevUiLoaderThrottleTest, InstallQueued) {
  mock_provider_.Reset();
  // Page 1 request.
  content::MockNavigationHandle handle1(GURL(kDevUiUrls[0]), main_rfh());
  content::MockNavigationThrottleRegistry registry1(
      &handle1,
      content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
  auto throttle1 = std::make_unique<TestDevUiLoaderThrottle>(registry1);
  // Page 2 request.
  content::MockNavigationHandle handle2(GURL(kDevUiUrls[1]), main_rfh());
  content::MockNavigationThrottleRegistry registry2(
      &handle2,
      content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
  auto throttle2 = std::make_unique<TestDevUiLoaderThrottle>(registry2);
  EXPECT_FALSE(mock_provider_.GetIsInstalled());
  EXPECT_FALSE(mock_provider_.GetIsLoaded());

  // Simulate request start of page 1. This triggers install.
  EXPECT_EQ(content::NavigationThrottle::DEFER, throttle1->WillStartRequest());

  // Simulate request start of page 2. This does not trigger install. However,
  // the on-complete callback is queued, and will be called.
  EXPECT_EQ(content::NavigationThrottle::DEFER, throttle2->WillStartRequest());

  // Simulate actual install.
  mock_provider_.SimulateAsyncInstall(true);  // !
  EXPECT_TRUE(throttle1->called_resume);
  EXPECT_FALSE(throttle1->called_cancel);
  EXPECT_TRUE(throttle2->called_resume);
  EXPECT_FALSE(throttle2->called_cancel);
  EXPECT_TRUE(mock_provider_.GetIsInstalled());
  EXPECT_TRUE(mock_provider_.GetIsLoaded());
}

TEST_F(DevUiLoaderThrottleTest, InstallRedundant) {
  mock_provider_.Reset();
  // Page 1 request.
  content::MockNavigationHandle handle1(GURL(kDevUiUrls[0]), main_rfh());
  content::MockNavigationThrottleRegistry registry1(
      &handle1,
      content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
  auto throttle1 = std::make_unique<TestDevUiLoaderThrottle>(registry1);
  // Page 2 request.
  content::MockNavigationHandle handle2(GURL(kDevUiUrls[1]), main_rfh());
  content::MockNavigationThrottleRegistry registry2(
      &handle2,
      content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
  auto throttle2 = std::make_unique<TestDevUiLoaderThrottle>(registry2);
  EXPECT_FALSE(mock_provider_.GetIsInstalled());
  EXPECT_FALSE(mock_provider_.GetIsLoaded());

  // Simulate request start of page 1.
  EXPECT_EQ(content::NavigationThrottle::DEFER, throttle1->WillStartRequest());

  // Simulate actual install.
  mock_provider_.SimulateAsyncInstall(true);  // !
  EXPECT_TRUE(throttle1->called_resume);
  EXPECT_FALSE(throttle1->called_cancel);
  EXPECT_TRUE(mock_provider_.GetIsInstalled());
  EXPECT_TRUE(mock_provider_.GetIsLoaded());

  // Simulate request start of page 2. The request was made before install
  // completes, but request start occurs after install completes. In this case,
  // simply proceed.
  EXPECT_EQ(content::NavigationThrottle::PROCEED,
            throttle2->WillStartRequest());
  EXPECT_FALSE(throttle2->called_resume);
  EXPECT_FALSE(throttle2->called_cancel);
  EXPECT_TRUE(mock_provider_.GetIsInstalled());
  EXPECT_TRUE(mock_provider_.GetIsLoaded());
}

TEST_F(DevUiLoaderThrottleTest, InstallFailure) {
  for (const char* url_string : kDevUiUrls) {
    mock_provider_.Reset();
    content::MockNavigationHandle handle(GURL(url_string), main_rfh());
    content::MockNavigationThrottleRegistry registry(
        &handle,
        content::MockNavigationThrottleRegistry::RegistrationMode::kHold);
    auto throttle = std::make_unique<TestDevUiLoaderThrottle>(registry);
    EXPECT_FALSE(throttle->called_resume);
    EXPECT_FALSE(throttle->called_cancel);
    EXPECT_FALSE(mock_provider_.GetIsInstalled());
    EXPECT_FALSE(mock_provider_.GetIsLoaded());

    // Simulate request start.
    EXPECT_EQ(content::NavigationThrottle::DEFER, throttle->WillStartRequest());
    EXPECT_FALSE(throttle->called_resume);
    EXPECT_FALSE(throttle->called_cancel);
    EXPECT_FALSE(mock_provider_.GetIsInstalled());
    EXPECT_FALSE(mock_provider_.GetIsLoaded());

    // Simulate actual install (failure)
    mock_provider_.SimulateAsyncInstall(false);  // !
    EXPECT_FALSE(throttle->called_resume);
    EXPECT_TRUE(throttle->called_cancel);
    EXPECT_FALSE(mock_provider_.GetIsInstalled());
    EXPECT_FALSE(mock_provider_.GetIsLoaded());
    EXPECT_EQ(content::NavigationThrottle::CANCEL,
              throttle->cancel_result.action());
    EXPECT_EQ(net::ERR_CONNECTION_FAILED,
              throttle->cancel_result.net_error_code());
    EXPECT_TRUE(throttle->cancel_result.error_page_content().has_value());
    std::string page_content =
        throttle->cancel_result.error_page_content().value();
    EXPECT_NE(std::string::npos, page_content.find("<!DOCTYPE html"));
  }
}

}  // namespace dev_ui