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

#include "components/webapps/browser/banners/app_banner_manager.h"

#include <map>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "base/auto_reset.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_future.h"
#include "build/build_config.h"
#include "chrome/browser/banners/app_banner_manager_browsertest_base.h"
#include "chrome/browser/profiles/profile.h"
#include "components/network_session_configurator/common/network_switches.h"
#include "components/webapps/browser/banners/app_banner_metrics.h"
#include "components/webapps/browser/banners/app_banner_settings_helper.h"
#include "components/webapps/browser/banners/install_banner_config.h"
#include "components/webapps/browser/banners/installable_web_app_check_result.h"
#include "components/webapps/browser/banners/web_app_banner_data.h"
#include "components/webapps/browser/features.h"
#include "components/webapps/browser/installable/installable_data.h"
#include "components/webapps/browser/installable/installable_logging.h"
#include "components/webapps/browser/installable/installable_manager.h"
#include "components/webapps/browser/installable/installable_metrics.h"
#include "content/public/browser/back_forward_cache.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/common/content_features.h"
#include "content/public/test/back_forward_cache_util.h"
#include "content/public/test/browser_test.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/fenced_frame_test_util.h"
#include "content/public/test/mock_web_contents_observer.h"
#include "content/public/test/prerender_test_util.h"
#include "content/public/test/test_utils.h"
#include "net/dns/mock_host_resolver.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/manifest/manifest_util.h"
#if !BUILDFLAG(IS_ANDROID)
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
#include "chrome/browser/web_applications/web_app_install_info.h"
#endif

namespace webapps {

using State = AppBannerManager::State;

// Browser tests for web app banners.
// NOTE: this test relies on service workers; failures and flakiness may be due
// to changes in SW code.
// TODO(http://crbug.com/329145718): Use AppBannerManagerNoFakeBrowserTest style
// instead of overriding like this.
// TODO(http://crbug.com/322342499): Completely remove this class.
class AppBannerManagerTest : public AppBannerManager {
 public:
  explicit AppBannerManagerTest(content::WebContents* web_contents)
      : AppBannerManager(web_contents) {}

  AppBannerManagerTest(const AppBannerManagerTest&) = delete;
  AppBannerManagerTest& operator=(const AppBannerManagerTest&) = delete;

  ~AppBannerManagerTest() override = default;

  bool TriggeringDisabledForTesting() const override { return false; }

  void RequestAppBanner() override {
    // Filter out about:blank navigations - we use these in testing to force
    // Stop() to be called.
    if (validated_url_ == GURL("about:blank")) {
      return;
    }

    AppBannerManager::RequestAppBanner();
  }

  bool banner_shown() { return banner_shown_.get() && *banner_shown_; }

  std::optional<WebappInstallSource> install_source() {
    return install_source_;
  }

  void clear_will_show() { banner_shown_.reset(); }

  State state() { return AppBannerManager::state(); }

  // Configures a callback to be invoked when the app banner flow finishes.
  void PrepareDone(base::OnceClosure on_done) { on_done_ = std::move(on_done); }

  // Configures a callback to be invoked from OnBannerPromptReply.
  void PrepareBannerPromptReply(base::OnceClosure on_banner_prompt_reply) {
    on_banner_prompt_reply_ = std::move(on_banner_prompt_reply);
  }

  void OnMlInstallPrediction(base::PassKey<MLInstallabilityPromoter>,
                             std::string result_label) override {}

 protected:
  bool CanRequestAppBanner() const override { return true; }

  InstallableParams ParamsToPerformInstallableWebAppCheck() override {
    InstallableParams params;
    params.valid_primary_icon = true;
    params.installable_criteria =
        InstallableCriteria::kImplicitManifestFieldsHTML;
    params.fetch_screenshots = true;
    return params;
  }

  bool ShouldDoNativeAppCheck(
      const blink::mojom::Manifest& manifest) const override {
    return false;
  }

  void DoNativeAppInstallableCheck(content::WebContents* web_contents,
                                   const GURL& validated_url,
                                   const blink::mojom::Manifest& manifest,
                                   NativeCheckCallback callback) override {
    NOTREACHED();
  }

  void OnWebAppInstallableCheckedNoErrors(
      const ManifestId& manifest_id) const override {}

  base::expected<void, InstallableStatusCode> CanRunWebAppInstallableChecks(
      const blink::mojom::Manifest& manifest) override {
    return base::ok();
  }

  void MaybeShowAmbientBadge(const InstallBannerConfig& config) override {
    return;
  }

  void ResetCurrentPageData() override {}

  // The overridden RequestAppBanner() can filter out about:blank calls
  // to force Stop() to be called, however, the newly introduced
  // AppBannerManagerBrowserTestWithChromeBFCache starts a server and navigates
  // to a dynamic/installable banner link and then retriggers the pipeline by
  // terminating an existing banner. As a result, there can exist banners in an
  // intermediary state (on_done_ not initialized, banner still shown) that
  // needs to be cleaned in these overridden functions for Stop() and
  // UpdateState(State::PENDING).
  //
  // As a result, calls to RequestAppBanner should always terminate in
  // ShowBannerUi(), but not necessarily in Stop() (not showing banner).
  // Override these methods to capture test status.
  void Stop(InstallableStatusCode code) override {
    AppBannerManager::Stop(code);
    if (banner_shown_)
      clear_will_show();
    ASSERT_FALSE(banner_shown_.get());
    banner_shown_ = std::make_unique<bool>(false);
    install_source_ = std::nullopt;
    if (on_done_)
      base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
          FROM_HERE, std::move(on_done_));
  }

  void ShowBannerUi(WebappInstallSource install_source,
                    const InstallBannerConfig& config) override {
    // Fake the call to ReportStatus here - this is usually called in
    // platform-specific code which is not exposed here.
    ReportStatus(InstallableStatusCode::SHOWING_WEB_APP_BANNER);
    ASSERT_FALSE(banner_shown_.get());
    banner_shown_ = std::make_unique<bool>(true);
    install_source_ = install_source;
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, std::move(on_done_));
  }

  void UpdateState(AppBannerManager::State state) override {
    AppBannerManager::UpdateState(state);
    if (state == AppBannerManager::State::PENDING_PROMPT_CANCELED ||
        state == AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED) {
      if (on_done_)
        base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
            FROM_HERE, std::move(on_done_));
    }
  }

  void OnBannerPromptReply(
      const InstallBannerConfig& install_config,
      mojo::Remote<blink::mojom::AppBannerController> controller,
      blink::mojom::AppBannerPromptReply reply) override {
    AppBannerManager::OnBannerPromptReply(install_config, std::move(controller),
                                          reply);
    if (on_banner_prompt_reply_) {
      base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
          FROM_HERE, std::move(on_banner_prompt_reply_));
    }
  }

  base::WeakPtr<AppBannerManager> GetWeakPtrForThisNavigation() override {
    return weak_factory_.GetWeakPtr();
  }

  void InvalidateWeakPtrsForThisNavigation() override {
    weak_factory_.InvalidateWeakPtrs();
  }

  bool IsSupportedNonWebAppPlatform(
      const std::u16string& platform) const override {
    return base::EqualsASCII(platform, "chrome_web_store");
  }

  bool IsRelatedNonWebAppInstalled(
      const blink::Manifest::RelatedApplication& related_app) const override {
    // Corresponds to the id listed in manifest_listing_related_chrome_app.json.
    return base::EqualsASCII(related_app.platform.value_or(std::u16string()),
                             "chrome_web_store") &&
           base::EqualsASCII(related_app.id.value_or(std::u16string()),
                             "installed-extension-id");
  }

  base::OnceClosure on_done_;

 private:
  // If non-null, |on_banner_prompt_reply_| will be invoked from
  // OnBannerPromptReply.
  base::OnceClosure on_banner_prompt_reply_;

  std::unique_ptr<bool> banner_shown_;
  std::optional<WebappInstallSource> install_source_;

  base::WeakPtrFactory<AppBannerManagerTest> weak_factory_{this};
};


enum class CheckWebAppExistence { kAsync = 0, kSync = 1, kMaxValue = kSync };

class AppBannerManagerBrowserTest
    : public AppBannerManagerBrowserTestBase,
      public ::testing::WithParamInterface<CheckWebAppExistence> {
 public:
  AppBannerManagerBrowserTest()
      : disable_banner_trigger_(&test::g_disable_banner_triggering_for_testing,
                                true) {}

  AppBannerManagerBrowserTest(const AppBannerManagerBrowserTest&) = delete;
  AppBannerManagerBrowserTest& operator=(const AppBannerManagerBrowserTest&) =
      delete;

  void SetUpCommandLine(base::CommandLine* command_line) override {
    if (GetParam() == CheckWebAppExistence::kAsync) {
      feature_list_.InitAndEnableFeature(features::kCheckWebAppExistenceAsync);
    } else {
      feature_list_.InitAndDisableFeature(features::kCheckWebAppExistenceAsync);
    }
  }

 protected:
  std::unique_ptr<AppBannerManagerTest> CreateAppBannerManager() {
    content::WebContents* web_contents =
        chrome_test_utils::GetActiveWebContents(this);
    return std::make_unique<AppBannerManagerTest>(web_contents);
  }

  void RunBannerTest(
      content::WebContents* web_contents,
      AppBannerManagerTest* manager,
      const GURL& url,
      std::optional<InstallableStatusCode> expected_code_for_histogram,
      bool is_off_the_record = false) {
    base::HistogramTester histograms;

    // Spin the run loop and wait for the manager to finish.
    base::RunLoop run_loop;
    manager->clear_will_show();
    manager->PrepareDone(run_loop.QuitClosure());
    ASSERT_TRUE(content::NavigateToURL(web_contents, url));
    run_loop.Run();

    EXPECT_EQ(expected_code_for_histogram.value_or(
                  InstallableStatusCode::MAX_ERROR_CODE) ==
                  InstallableStatusCode::SHOWING_WEB_APP_BANNER,
              manager->banner_shown());
    EXPECT_EQ(std::nullopt, manager->install_source());

    // Generally the manager will be in the complete state, however some test
    // cases navigate the page, causing the state to go back to INACTIVE.
    EXPECT_TRUE(manager->state() == State::COMPLETE ||
                manager->state() == State::PENDING_PROMPT_CANCELED ||
                manager->state() == State::PENDING_PROMPT_NOT_CANCELED ||
                manager->state() == State::INACTIVE);

    // If in incognito, ensure that nothing is recorded.
    if (is_off_the_record || !expected_code_for_histogram) {
      histograms.ExpectTotalCount(kInstallableStatusCodeHistogram, 0);
    } else {
      EXPECT_THAT(histograms.GetAllSamples(kInstallableStatusCodeHistogram),
                  base::BucketsAre(base::Bucket(
                      expected_code_for_histogram.value(), /*count=*/1)));
    }
  }

  void TriggerBannerFlowWithNavigation(AppBannerManagerTest* manager,
                                       const GURL& url,
                                       bool expected_will_show,
                                       std::optional<State> expected_state) {
    // Use NavigateToURLWithDisposition as it isn't overloaded, so can be used
    // with Bind.
    TriggerBannerFlow(
        manager, base::BindLambdaForTesting([&]() {
          ASSERT_TRUE(content::NavigateToURL(web_contents(), url));
        }),
        expected_will_show, expected_state);
  }

  void TriggerBannerFlow(AppBannerManagerTest* manager,
                         base::OnceClosure trigger_task,
                         bool expected_will_show,
                         std::optional<State> expected_state) {
    base::RunLoop run_loop;
    manager->clear_will_show();
    manager->PrepareDone(run_loop.QuitClosure());
    std::move(trigger_task).Run();
    run_loop.Run();

    EXPECT_EQ(expected_will_show, manager->banner_shown());
    if (expected_state)
      EXPECT_EQ(expected_state, manager->state());
  }

 private:
  // Disable the banners in the browser so it won't interfere with the test.
  base::AutoReset<bool> disable_banner_trigger_;
  base::test::ScopedFeatureList feature_list_;
};

// TODO(crbug.com/370270547): Many tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_WebAppBannerNoTypeInManifest DISABLED_WebAppBannerNoTypeInManifest
#else
#define MAYBE_WebAppBannerNoTypeInManifest WebAppBannerNoTypeInManifest
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_WebAppBannerNoTypeInManifest) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(web_contents(), manager.get(),
                GetBannerURLWithManifest("/banners/manifest_no_type.json"),
                std::nullopt);
}

// TODO(crbug.com/370270547): Many tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_WebAppBannerNoTypeInManifestCapsExtension \
  DISABLED_WebAppBannerNoTypeInManifestCapsExtension
#else
#define MAYBE_WebAppBannerNoTypeInManifestCapsExtension \
  WebAppBannerNoTypeInManifestCapsExtension
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_WebAppBannerNoTypeInManifestCapsExtension) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(web_contents(), manager.get(),
                GetBannerURLWithManifest("/banners/manifest_no_type_caps.json"),
                std::nullopt);
}

// TODO(crbug.com/370270547): Many tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_WebAppBannerSvgIcon DISABLED_WebAppBannerSvgIcon
#else
#define MAYBE_WebAppBannerSvgIcon WebAppBannerSvgIcon
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, MAYBE_WebAppBannerSvgIcon) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(web_contents(), manager.get(),
                GetBannerURLWithManifest("/banners/manifest_svg_icon.json"),
                std::nullopt);
}

// TODO(crbug.com/370270547): Many tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_WebAppBannerWebPIcon DISABLED_WebAppBannerWebPIcon
#else
#define MAYBE_WebAppBannerWebPIcon WebAppBannerWebPIcon
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_WebAppBannerWebPIcon) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(web_contents(), manager.get(),
                GetBannerURLWithManifest("/banners/manifest_webp_icon.json"),
                std::nullopt);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       DelayedManifestTriggersPipeline) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(
      web_contents(), manager.get(),
      embedded_test_server()->GetURL("/banners/no_manifest_test_page.html"),
      InstallableStatusCode::NO_MANIFEST);

  // Dynamically add the manifest.
  base::HistogramTester histograms;
  TriggerBannerFlow(
      manager.get(), base::BindLambdaForTesting([&]() {
        EXPECT_TRUE(content::ExecJs(web_contents(), "addManifestLinkTag()"));
      }),
      /*expected_will_show=*/false, std::nullopt);
  TriggerBannerFlow(manager.get(), base::DoNothing(),
                    /*expected_will_show=*/false,
                    AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  histograms.ExpectTotalCount(kInstallableStatusCodeHistogram, 0);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       RemovingManifestStopsPipeline) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(
      web_contents(), manager.get(),
      embedded_test_server()->GetURL("/banners/manifest_test_page.html"),
      std::nullopt);
  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);

  // Dynamically remove the manifest.
  base::HistogramTester histograms;
  TriggerBannerFlow(
      manager.get(), base::BindLambdaForTesting([&]() {
        EXPECT_TRUE(content::ExecJs(web_contents(), "removeAllManifestTags()"));
      }),
      false, AppBannerManager::State::COMPLETE);
  histograms.ExpectTotalCount(kInstallableStatusCodeHistogram, 1);
  histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                InstallableStatusCode::NO_MANIFEST, 1);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       ManifestChangeTriggersPipeline) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  // Cause the manifest test page to reach the PENDING_PROMPT stage of the
  // app banner pipeline.
  RunBannerTest(
      web_contents(), manager.get(),
      embedded_test_server()->GetURL("/banners/manifest_test_page.html"),
      std::nullopt);
  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);

  // Dynamically change the manifest, which results in a
  // Stop(MANIFEST_URL_CHANGED), and a restart of the pipeline.
  {
    base::HistogramTester histograms;
    // Note - The state of the appbannermanager here will be racy, so don't
    // check for that.
    TriggerBannerFlow(
        manager.get(), base::BindLambdaForTesting([&]() {
          EXPECT_TRUE(content::ExecJs(
              web_contents(),
              "addManifestLinkTag('/banners/manifest_one_icon.json')"));
        }),
        false, std::nullopt);
    histograms.ExpectTotalCount(kInstallableStatusCodeHistogram, 1);
    histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                  InstallableStatusCode::MANIFEST_URL_CHANGED,
                                  1);
  }
  // The pipeline should either have completed, or it is scheduled in the
  // background. Wait for the next prompt request if so.
  if (manager->state() !=
      AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED) {
    base::HistogramTester histograms;
    base::RunLoop run_loop;
    manager->PrepareDone(run_loop.QuitClosure());
    run_loop.Run();
    histograms.ExpectTotalCount(kInstallableStatusCodeHistogram, 0);
  }
  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       NoPageManifestProvidesDefaultManifest) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  GURL page_url =
      embedded_test_server()->GetURL("/banners/no_manifest_test_page.html");
  RunBannerTest(web_contents(), manager.get(), page_url,
                InstallableStatusCode::NO_MANIFEST);
  std::optional<WebAppBannerData> banner =
      manager->GetCurrentWebAppBannerData();
  // Check the default manifest was populated.
  ASSERT_TRUE(banner);
  EXPECT_TRUE(blink::IsDefaultManifest(banner->manifest(), page_url));
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, MissingManifest) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(web_contents(), manager.get(),
                GetBannerURLWithManifest("/banners/manifest_missing.json"),
                InstallableStatusCode::MANIFEST_PARSING_OR_NETWORK_ERROR);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, WebAppBannerInIFrame) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  GURL url = embedded_test_server()->GetURL("/banners/iframe_test_page.html");
  RunBannerTest(web_contents(), manager.get(), url,
                InstallableStatusCode::NO_MANIFEST);
  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            webapps::InstallableWebAppCheckResult::kNo);
  // The banner will be the default one for the current page.
  std::optional<WebAppBannerData> banner =
      manager->GetCurrentWebAppBannerData();
  ASSERT_TRUE(banner);
  EXPECT_TRUE(blink::IsDefaultManifest(banner->manifest(), url));
}

#if !BUILDFLAG(IS_ANDROID)
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, DoesNotShowInIncognito) {
  Browser* incognito_browser =
      OpenURLOffTheRecord(browser()->profile(), GURL("about:blank"));
  content::WebContents* web_contents =
      incognito_browser->tab_strip_model()->GetActiveWebContents();
  std::unique_ptr<AppBannerManagerTest> manager =
      std::make_unique<AppBannerManagerTest>(web_contents);
  RunBannerTest(web_contents, manager.get(), GetBannerURL(),
                InstallableStatusCode::IN_INCOGNITO, true);
}
#endif

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, WebAppBannerNotCreated) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  GURL test_url = GetBannerURL();

  // Navigate and expect the manager to end up waiting for prompt to be called.
  TriggerBannerFlowWithNavigation(manager.get(), test_url,
                                  false /* expected_will_show */,
                                  State::PENDING_PROMPT_NOT_CANCELED);

  // Navigate and expect Stop() to be called.
  TriggerBannerFlowWithNavigation(manager.get(), GURL("about:blank"),
                                  false /* expected_will_show */,
                                  State::INACTIVE);

  histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                InstallableStatusCode::RENDERER_CANCELLED, 1);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, WebAppBannerCancelled) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  // Explicitly call preventDefault(), but don't call prompt().
  GURL test_url = GetBannerURLWithAction("cancel_prompt");

  // Navigate and expect the manager to end up waiting for prompt() to be
  // called.
  TriggerBannerFlowWithNavigation(manager.get(), test_url,
                                  false /* expected_will_show */,
                                  State::PENDING_PROMPT_CANCELED);

  // Navigate to about:blank and expect Stop() to be called.
  TriggerBannerFlowWithNavigation(manager.get(), GURL("about:blank"),
                                  false /* expected_will_show */,
                                  State::INACTIVE);

  histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                InstallableStatusCode::RENDERER_CANCELLED, 1);
}

// TODO(crbug.com/370270547): Many tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_WebAppBannerPromptWithGesture \
  DISABLED_WebAppBannerPromptWithGesture
#else
#define MAYBE_WebAppBannerPromptWithGesture WebAppBannerPromptWithGesture
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_WebAppBannerPromptWithGesture) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  GURL test_url = GetBannerURLWithAction("stash_event");

  // Navigate to page and get the pipeline started.
  TriggerBannerFlowWithNavigation(manager.get(), test_url,
                                  false /* expected_will_show */,
                                  State::PENDING_PROMPT_NOT_CANCELED);

  // Now let the page call prompt with a gesture. The banner should be shown.
  TriggerBannerFlow(manager.get(),
                    base::BindOnce(&AppBannerManagerBrowserTest::ExecuteScript,
                                   web_contents(), "callStashedPrompt();",
                                   true /* with_gesture */),
                    true /* expected_will_show */, State::COMPLETE);

  histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                InstallableStatusCode::SHOWING_WEB_APP_BANNER,
                                1);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, WebAppBannerReprompt) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  GURL test_url = GetBannerURLWithAction("stash_event");

  // Navigate to page and get the pipeline started.
  TriggerBannerFlowWithNavigation(manager.get(), test_url,
                                  false /* expected_will_show */,
                                  State::PENDING_PROMPT_NOT_CANCELED);

  // Call prompt to show the banner.
  TriggerBannerFlow(manager.get(),
                    base::BindOnce(&AppBannerManagerBrowserTest::ExecuteScript,
                                   web_contents(), "callStashedPrompt();",
                                   true /* with_gesture */),
                    true /* expected_will_show */, State::COMPLETE);

  // Dismiss the banner.
  base::RunLoop run_loop;
  manager->PrepareDone(base::DoNothing());
  manager->PrepareBannerPromptReply(run_loop.QuitClosure());
  manager->SendBannerDismissed();
  // Wait for OnBannerPromptReply event.
  run_loop.Run();

  // Call prompt again to show the banner again.
  TriggerBannerFlow(manager.get(),
                    base::BindOnce(&AppBannerManagerBrowserTest::ExecuteScript,
                                   web_contents(), "callStashedPrompt();",
                                   true /* with_gesture */),
                    true /* expected_will_show */, State::COMPLETE);

  histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                InstallableStatusCode::SHOWING_WEB_APP_BANNER,
                                1);
}

// Flaky on Android. crbug.com/369804412
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_PreferRelatedAppUnknown DISABLED_PreferRelatedAppUnknown
#else
#define MAYBE_PreferRelatedAppUnknown PreferRelatedAppUnknown
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_PreferRelatedAppUnknown) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  GURL test_url = embedded_test_server()->GetURL(
      "/banners/manifest_test_page.html?manifest="
      "manifest_prefer_related_apps_unknown.json");
  TriggerBannerFlowWithNavigation(manager.get(), test_url,
                                  false /* expected_will_show */,
                                  State::PENDING_PROMPT_NOT_CANCELED);
}

// Flaky on Android. crbug.com/369804412
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_PreferRelatedChromeApp DISABLED_PreferRelatedChromeApp
#else
#define MAYBE_PreferRelatedChromeApp PreferRelatedChromeApp
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_PreferRelatedChromeApp) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  GURL test_url = embedded_test_server()->GetURL(
      "/banners/manifest_test_page.html?manifest="
      "manifest_prefer_related_chrome_app.json");
  TriggerBannerFlowWithNavigation(
      manager.get(), test_url, false /* expected_will_show */, State::COMPLETE);
  histograms.ExpectUniqueSample(
      kInstallableStatusCodeHistogram,
      InstallableStatusCode::PREFER_RELATED_APPLICATIONS, 1);
}

// TODO(crbug.com/370270547): Many related tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_ListedRelatedChromeAppInstalled \
  DISABLED_ListedRelatedChromeAppInstalled
#else
#define MAYBE_ListedRelatedChromeAppInstalled ListedRelatedChromeAppInstalled
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_ListedRelatedChromeAppInstalled) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  GURL test_url = embedded_test_server()->GetURL(
      "/banners/manifest_test_page.html?manifest="
      "manifest_listing_related_chrome_app.json");
  TriggerBannerFlowWithNavigation(
      manager.get(), test_url, false /* expected_will_show */, State::COMPLETE);
  histograms.ExpectUniqueSample(
      kInstallableStatusCodeHistogram,
      InstallableStatusCode::PREFER_RELATED_APPLICATIONS, 1);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, WebAppBannerTerminated) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  base::HistogramTester histograms;

  GURL test_url = GetBannerURL();

  // Navigate and expect the manager to end up waiting for prompt() to be
  // called.
  TriggerBannerFlowWithNavigation(manager.get(), test_url,
                                  false /* expected_will_show */,
                                  State::PENDING_PROMPT_NOT_CANCELED);

  // Navigate to about:blank and expect it to be terminated because the previous
  // URL is still pending.
  TriggerBannerFlowWithNavigation(manager.get(), GURL("about:blank"),
                                  false /* expected_will_show */,
                                  State::INACTIVE);

  // Expect the installation config to be empty, as the page is not eligible
  // for installation.
  EXPECT_EQ(manager->GetCurrentWebAppBannerData(), std::nullopt);
  EXPECT_EQ(manager->GetCurrentBannerConfig(), std::nullopt);

  // Expect RENDERER_CANCELLED to be called when an existing call is terminated.
  histograms.ExpectUniqueSample(kInstallableStatusCodeHistogram,
                                InstallableStatusCode::RENDERER_CANCELLED, 1);
}

class AppBannerManagerBrowserTestWithChromeBFCache
    : public AppBannerManagerBrowserTest {
 public:
  AppBannerManagerBrowserTestWithChromeBFCache() = default;
  ~AppBannerManagerBrowserTestWithChromeBFCache() override = default;

  void SetUpOnMainThread() override {
    host_resolver()->AddRule("*", "127.0.0.1");
  }

  void SetUpCommandLine(base::CommandLine* command_line) override {
    // For using an HTTPS server.
    base::CommandLine::ForCurrentProcess()->AppendSwitch(
        switches::kIgnoreCertificateErrors);

    SetupFeaturesAndParameters();
  }

  void SetupFeaturesAndParameters() {
    feature_list_.InitWithFeaturesAndParameters(
        content::GetDefaultEnabledBackForwardCacheFeaturesForTesting(),
        content::GetDefaultDisabledBackForwardCacheFeaturesForTesting());
  }

  content::RenderFrameHost* current_frame_host() {
    return web_contents()->GetPrimaryMainFrame();
  }

  GURL Get2ndInstallableURL() {
    return embedded_test_server()->GetURL("/banners/nested_sw_test_page.html");
  }

  bool IsRenderHostStoredInBackForwardCache(content::RenderFrameHost* rfh) {
    return rfh->IsInLifecycleState(
        content::RenderFrameHost::LifecycleState::kInBackForwardCache);
  }

  void AssertBackForwardCacheIsUsedAsExpected(
      const content::RenderFrameHostWrapper& rfh) {
    ASSERT_EQ(IsRenderHostStoredInBackForwardCache(rfh.get()),
              content::BackForwardCache::IsBackForwardCacheFeatureEnabled());
  }

 private:
  base::test::ScopedFeatureList feature_list_;
};

IN_PROC_BROWSER_TEST_F(AppBannerManagerBrowserTestWithChromeBFCache,
                       VerifyBFCacheBehavior) {
  ASSERT_TRUE(embedded_test_server()->Start());
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  base::HistogramTester histograms;
  // Triggering flow to first URL with a pending prompt.
  TriggerBannerFlowWithNavigation(manager.get(), GetBannerURL(),
                                  /*expected_will_show=*/false,
                                  State::PENDING_PROMPT_NOT_CANCELED);
  content::RenderFrameHostWrapper rfh_a(current_frame_host());
  ASSERT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  histograms.ExpectTotalCount(kInstallableStatusCodeHistogram, 0);

  // Navigating to 2nd installable URL while PENDING_PROMPT will trigger
  // the pipeline.
  TriggerBannerFlowWithNavigation(manager.get(), Get2ndInstallableURL(),
                                  /*expected_will_show=*/false, std::nullopt);
  AssertBackForwardCacheIsUsedAsExpected(rfh_a);

  content::RenderFrameHostWrapper rfh_b(current_frame_host());

  // Navigate backward to 1st installable URL.
  web_contents()->GetController().GoBack();
  ASSERT_TRUE(content::WaitForLoadStop(web_contents()));
  // Verify pipeline has been triggered for new page load.
  EXPECT_NE(manager->state(), AppBannerManager::State::INACTIVE);

  AssertBackForwardCacheIsUsedAsExpected(rfh_b);

  // Navigate forward to 2nd installable URL.
  web_contents()->GetController().GoForward();
  ASSERT_TRUE(content::WaitForLoadStop(web_contents()));
  // Verify pipeline has been triggered for new page load.
  EXPECT_NE(manager->state(), AppBannerManager::State::INACTIVE);

  AssertBackForwardCacheIsUsedAsExpected(rfh_a);
}

namespace {
class FailingInstallableManager : public InstallableManager {
 public:
  explicit FailingInstallableManager(content::WebContents* web_contents)
      : InstallableManager(web_contents) {}

  void FailNext(std::unique_ptr<InstallableData> installable_data) {
    failure_data_ = std::move(installable_data);
  }

  void GetData(const InstallableParams& params,
               InstallableCallback callback) override {
    if (failure_data_) {
      auto temp_data = std::move(failure_data_);
      std::move(callback).Run(*temp_data);
      return;
    }
    InstallableManager::GetData(params, std::move(callback));
  }

 private:
  std::unique_ptr<InstallableData> failure_data_;
};

class AppBannerManagerMPArchBrowserTest : public AppBannerManagerBrowserTest {
 public:
  AppBannerManagerMPArchBrowserTest() = default;
  ~AppBannerManagerMPArchBrowserTest() override = default;
  AppBannerManagerMPArchBrowserTest(const AppBannerManagerMPArchBrowserTest&) =
      delete;

  AppBannerManagerMPArchBrowserTest& operator=(
      const AppBannerManagerMPArchBrowserTest&) = delete;

  void SetUpCommandLine(base::CommandLine* command_line) override {}

  void SetUpOnMainThread() override {
    host_resolver()->AddRule("*", "127.0.0.1");
    AppBannerManagerBrowserTest::SetUpOnMainThread();
  }
};

class AppBannerManagerPrerenderBrowserTest
    : public AppBannerManagerMPArchBrowserTest {
 public:
  AppBannerManagerPrerenderBrowserTest()
      : prerender_helper_(base::BindRepeating(
            &AppBannerManagerPrerenderBrowserTest::web_contents,
            base::Unretained(this))) {}
  ~AppBannerManagerPrerenderBrowserTest() override = default;
  AppBannerManagerPrerenderBrowserTest(
      const AppBannerManagerPrerenderBrowserTest&) = delete;

  AppBannerManagerPrerenderBrowserTest& operator=(
      const AppBannerManagerPrerenderBrowserTest&) = delete;

  void SetUp() override {
    prerender_helper_.RegisterServerRequestMonitor(embedded_test_server());
    AppBannerManagerMPArchBrowserTest::SetUp();
  }

  content::test::PrerenderTestHelper& prerender_test_helper() {
    return prerender_helper_;
  }

 private:
  content::test::PrerenderTestHelper prerender_helper_;
};

IN_PROC_BROWSER_TEST_F(AppBannerManagerPrerenderBrowserTest,
                       PrerenderingShouldNotUpdateState) {
  auto initial_url = embedded_test_server()->GetURL("/empty.html");
  ASSERT_TRUE(content::NavigateToURL(web_contents(), initial_url));

  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  EXPECT_EQ(manager->state(), AppBannerManager::State::INACTIVE);

  // Load a page in the prerender.
  GURL prerender_url = GetBannerURL();
  const content::FrameTreeNodeId host_id =
      prerender_test_helper().AddPrerender(prerender_url);
  content::test::PrerenderHostObserver host_observer(*web_contents(), host_id);
  EXPECT_FALSE(host_observer.was_activated());
  EXPECT_EQ(manager->state(), AppBannerManager::State::INACTIVE);

  // Activate the prerender page.
  prerender_test_helper().NavigatePrimaryPage(prerender_url);
  EXPECT_TRUE(host_observer.was_activated());
  EXPECT_EQ(manager->state(), AppBannerManager::State::FETCHING_MANIFEST);
}

class AppBannerManagerFencedFrameBrowserTest
    : public AppBannerManagerMPArchBrowserTest {
 public:
  AppBannerManagerFencedFrameBrowserTest() = default;
  ~AppBannerManagerFencedFrameBrowserTest() override = default;
  AppBannerManagerFencedFrameBrowserTest(
      const AppBannerManagerFencedFrameBrowserTest&) = delete;

  AppBannerManagerFencedFrameBrowserTest& operator=(
      const AppBannerManagerFencedFrameBrowserTest&) = delete;

  content::test::FencedFrameTestHelper& fenced_frame_test_helper() {
    return fenced_frame_helper_;
  }

 private:
  content::test::FencedFrameTestHelper fenced_frame_helper_;
};

IN_PROC_BROWSER_TEST_F(AppBannerManagerFencedFrameBrowserTest,
                       FencedFrameShouldNotUpdateState) {
  // Navigate to an initial page.
  const GURL initial_url = embedded_test_server()->GetURL("/empty.html");
  ASSERT_TRUE(content::NavigateToURL(web_contents(), initial_url));

  // Initialize a MockWebContentsObserver to ensure that DidUpdateManifestURL is
  // not invoked for fenced frame.
  testing::NiceMock<content::MockWebContentsObserver> observer(web_contents());

  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  EXPECT_EQ(manager->state(), AppBannerManager::State::INACTIVE);

  // Create a fenced frame.
  GURL fenced_frame_url = embedded_test_server()->GetURL(
      "/banners/fenced_frames/manifest_test_page.html?manifest=/banners/"
      "manifest.json");
  content::RenderFrameHost* fenced_frame_host =
      fenced_frame_test_helper().CreateFencedFrame(
          web_contents()->GetPrimaryMainFrame(), fenced_frame_url);
  EXPECT_NE(nullptr, fenced_frame_host);
  EXPECT_EQ(manager->state(), AppBannerManager::State::INACTIVE);

  // Cross check that  DidUpdateWebManifestURL is not called for fenced frame
  // RenderFrameHost.
  EXPECT_CALL(observer, DidUpdateWebManifestURL(fenced_frame_host, testing::_))
      .Times(0);

  // Navigate the fenced frame.
  fenced_frame_test_helper().NavigateFrameInFencedFrameTree(fenced_frame_host,
                                                            fenced_frame_url);
  EXPECT_EQ(manager->state(), AppBannerManager::State::INACTIVE);
}

// TODO(crbug.com/370270547): Many tests are failing.
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_ShowBanner DISABLED_ShowBanner
#else
#define MAYBE_ShowBanner ShowBanner
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, MAYBE_ShowBanner) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(
      web_contents(), manager.get(),
      embedded_test_server()->GetURL("/banners/manifest_test_page.html"),
      std::nullopt);
  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, NoServiceWorker) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  RunBannerTest(web_contents(), manager.get(),
                embedded_test_server()->GetURL(
                    "/banners/manifest_no_service_worker.html"),
                /*expected_code_for_histogram=*/std::nullopt);

  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, NoFetchHandler) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  RunBannerTest(web_contents(), manager.get(),
                embedded_test_server()->GetURL(
                    "/banners/no_sw_fetch_handler_test_page.html"),
                /*expected_code_for_histogram=*/std::nullopt);

  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);

  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, PendingServiceWorker) {
  std::unique_ptr<AppBannerManagerTest> manager =
      std::make_unique<AppBannerManagerTest>(web_contents());

  RunBannerTest(web_contents(), manager.get(),
                embedded_test_server()->GetURL(
                    "/banners/manifest_no_service_worker.html"),
                std::nullopt);

  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);

  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);

  ASSERT_TRUE(manager->GetCurrentBannerConfig());
  EXPECT_EQ(manager->GetCurrentBannerConfig()->GetWebOrNativeAppName(),
            u"Manifest test app");
}

// Flaky on Android. crbug.com/369804412
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_ValidManifestShowBanner DISABLED_ValidManifestShowBanner
#else
#define MAYBE_ValidManifestShowBanner ValidManifestShowBanner
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest,
                       MAYBE_ValidManifestShowBanner) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());
  RunBannerTest(
      web_contents(), manager.get(),
      embedded_test_server()->GetURL("/banners/manifest_test_page.html"),
      std::nullopt);
  EXPECT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);
}

// Flaky on Android. crbug.com/369804412
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_ImplicitName DISABLED_ImplicitName
#else
#define MAYBE_ImplicitName ImplicitName
#endif
IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, MAYBE_ImplicitName) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  GURL test_url = embedded_test_server()->GetURL(
      "/banners/manifest_test_page.html?manifest="
      "manifest_empty_name_short_name.json&application-name=TestApp");

  RunBannerTest(web_contents(), manager.get(), test_url, std::nullopt);

  ASSERT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);
  ASSERT_TRUE(manager->GetCurrentBannerConfig());
    EXPECT_EQ(manager->GetCurrentBannerConfig()->GetWebOrNativeAppName(),
              u"TestApp");
}

IN_PROC_BROWSER_TEST_P(AppBannerManagerBrowserTest, ImplicitNameDocumentTitle) {
  std::unique_ptr<AppBannerManagerTest> manager(CreateAppBannerManager());

  GURL test_url = embedded_test_server()->GetURL(
      "/banners/manifest_test_page.html?manifest="
      "manifest_empty_name_short_name.json");

  RunBannerTest(web_contents(), manager.get(), test_url, std::nullopt);

  ASSERT_EQ(manager->state(),
            AppBannerManager::State::PENDING_PROMPT_NOT_CANCELED);
  EXPECT_EQ(manager->GetInstallableWebAppCheckResult(),
            InstallableWebAppCheckResult::kYes_Promotable);
  ASSERT_TRUE(manager->GetCurrentBannerConfig());
    EXPECT_EQ(manager->GetCurrentBannerConfig()->GetWebOrNativeAppName(),
              u"Web app banner test page");
}

#if !BUILDFLAG(IS_ANDROID)
// TODO(http://crbug.com/329255543): Add the config data after the struct is
// converted to a class w/o const members (this makes it hard to work with
// TestFuture).
using AppBannerInstallableCallback =
    base::RepeatingCallback<void(std::optional<ManifestId>)>;
class AppBannerManagerObserverAdapter : public AppBannerManager::Observer {
 public:
  AppBannerManagerObserverAdapter(AppBannerManager* source,
                                  AppBannerInstallableCallback callback,
                                  InstallableWebAppCheckResult filter)
      : callback_(std::move(callback)), filter_(filter) {
    observation_.Observe(source);
  }

  void OnInstallableWebAppStatusUpdated(
      InstallableWebAppCheckResult result,
      const std::optional<WebAppBannerData>& data) override {
    if (result != filter_) {
      LOG(WARNING) << "Filtered result: " << base::ToString(result);
      return;
    }
    callback_.Run(data.has_value() ? std::make_optional(data->manifest_id)
                                   : std::nullopt);
  }

 private:
  AppBannerInstallableCallback callback_;
  InstallableWebAppCheckResult filter_;
  base::ScopedObservation<AppBannerManager, AppBannerManager::Observer>
      observation_{this};
};

// Test class that doesn't do complex faking of the AppBannerManager.
class AppBannerManagerNoFakeBrowserTest
    : public AppBannerManagerBrowserTestBase {
 public:
  AppBannerManagerNoFakeBrowserTest() = default;

 private:
  // Disable the banners in the browser so it won't interfere with the test.
  base::test::ScopedFeatureList feature_list_;
};

IN_PROC_BROWSER_TEST_F(AppBannerManagerNoFakeBrowserTest, Prompts) {
  const GURL kAppUrl =
      embedded_test_server()->GetURL("/banners/manifest_test_page.html");

  AppBannerManager* app_banner_manager =
      AppBannerManager::FromWebContents(web_contents());
  base::test::TestFuture<std::optional<ManifestId>> future;
  AppBannerManagerObserverAdapter observer(
      app_banner_manager, future.GetRepeatingCallback(),
      InstallableWebAppCheckResult::kYes_Promotable);

  ASSERT_TRUE(content::NavigateToURL(web_contents(), kAppUrl));

  ASSERT_TRUE(future.Wait());
  EXPECT_EQ(kAppUrl, future.Get());
}

IN_PROC_BROWSER_TEST_F(AppBannerManagerNoFakeBrowserTest,
                       PromptsForInnerCraftedOuterDiy) {
  const GURL kDiyAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/index.html");
  const GURL kInnerAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/nested/index.html");

  // Install a DIY app.
  auto web_app_info =
      web_app::WebAppInstallInfo::CreateWithStartUrlForTesting(kDiyAppUrl);
  web_app_info->is_diy_app = true;
  web_app_info->title = u"test web app";
  web_app_info->user_display_mode =
      web_app::mojom::UserDisplayMode::kStandalone;
  web_app::test::InstallWebApp(profile(), std::move(web_app_info));

  AppBannerManager* app_banner_manager =
      AppBannerManager::FromWebContents(web_contents());
  base::test::TestFuture<std::optional<ManifestId>> future;
  AppBannerManagerObserverAdapter observer(
      app_banner_manager, future.GetRepeatingCallback(),
      InstallableWebAppCheckResult::kYes_Promotable);
  ASSERT_TRUE(content::NavigateToURL(web_contents(), kInnerAppUrl));

  ASSERT_TRUE(future.Wait());
  EXPECT_EQ(kInnerAppUrl, future.Get());
}

IN_PROC_BROWSER_TEST_F(AppBannerManagerNoFakeBrowserTest,
                       NoPromptsForInnerDiyOuterDiy) {
  const GURL kDiyAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/index.html");
  const GURL kInnerDiyAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/nested/diy.html");

  // Install a DIY app.
  auto web_app_info =
      web_app::WebAppInstallInfo::CreateWithStartUrlForTesting(kDiyAppUrl);
  web_app_info->is_diy_app = true;
  web_app_info->title = u"test web app";
  web_app_info->user_display_mode =
      web_app::mojom::UserDisplayMode::kStandalone;
  web_app::test::InstallWebApp(profile(), std::move(web_app_info));

  AppBannerManager* app_banner_manager =
      AppBannerManager::FromWebContents(web_contents());
  base::test::TestFuture<std::optional<ManifestId>> future;
  AppBannerManagerObserverAdapter observer(app_banner_manager,
                                           future.GetRepeatingCallback(),
                                           InstallableWebAppCheckResult::kNo);
  ASSERT_TRUE(content::NavigateToURL(web_contents(), kInnerDiyAppUrl));

  ASSERT_TRUE(future.Wait());
  EXPECT_EQ(kInnerDiyAppUrl, future.Get());
}

IN_PROC_BROWSER_TEST_F(AppBannerManagerNoFakeBrowserTest,
                       NoPromptForOuterCraftedDisplayBrowserInnerCrafted) {
  const GURL kOuterAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/index.html");
  const GURL kInnerAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/nested/index.html");

  // Even if the outer crafted app opens in a browser tab, it should still block
  // any nested installations.
  auto web_app_info =
      web_app::WebAppInstallInfo::CreateWithStartUrlForTesting(kOuterAppUrl);
  web_app_info->title = u"test web app";
  web_app_info->user_display_mode = web_app::mojom::UserDisplayMode::kBrowser;
  web_app::test::InstallWebApp(profile(), std::move(web_app_info));

  AppBannerManager* app_banner_manager =
      AppBannerManager::FromWebContents(web_contents());
  base::test::TestFuture<std::optional<ManifestId>> future;
  AppBannerManagerObserverAdapter observer(
      app_banner_manager, future.GetRepeatingCallback(),
      InstallableWebAppCheckResult::kNo_AlreadyInstalled);
  ASSERT_TRUE(content::NavigateToURL(web_contents(), kInnerAppUrl));

  ASSERT_TRUE(future.Wait());
  EXPECT_EQ(kInnerAppUrl, future.Get());
}

IN_PROC_BROWSER_TEST_F(AppBannerManagerNoFakeBrowserTest,
                       NoPromptForOuterCraftedDisplayStandaloneInnerCrafted) {
  const GURL kOuterAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/index.html");
  const GURL kInnerAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/nested/index.html");

  auto web_app_info =
      web_app::WebAppInstallInfo::CreateWithStartUrlForTesting(kOuterAppUrl);
  web_app_info->title = u"test web app";
  web_app_info->user_display_mode =
      web_app::mojom::UserDisplayMode::kStandalone;
  web_app::test::InstallWebApp(profile(), std::move(web_app_info));

  AppBannerManager* app_banner_manager =
      AppBannerManager::FromWebContents(web_contents());
  base::test::TestFuture<std::optional<ManifestId>> future;
  AppBannerManagerObserverAdapter observer(
      app_banner_manager, future.GetRepeatingCallback(),
      InstallableWebAppCheckResult::kNo_AlreadyInstalled);
  ASSERT_TRUE(content::NavigateToURL(web_contents(), kInnerAppUrl));

  ASSERT_TRUE(future.Wait());
  EXPECT_EQ(kInnerAppUrl, future.Get());
}

IN_PROC_BROWSER_TEST_F(AppBannerManagerNoFakeBrowserTest,
                       NoPromptForOuterCraftedDisplayBrowserInnerDiy) {
  const GURL kOuterAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/index.html");
  const GURL kInnerAppUrl =
      embedded_test_server()->GetURL("/web_apps/nesting/nested/diy.html");

  // Install a DIY app.
  auto web_app_info =
      web_app::WebAppInstallInfo::CreateWithStartUrlForTesting(kOuterAppUrl);
  web_app_info->title = u"test web app";
  web_app_info->user_display_mode = web_app::mojom::UserDisplayMode::kBrowser;
  web_app::test::InstallWebApp(profile(), std::move(web_app_info));

  AppBannerManager* app_banner_manager =
      AppBannerManager::FromWebContents(web_contents());
  base::test::TestFuture<std::optional<ManifestId>> future;
  AppBannerManagerObserverAdapter observer(app_banner_manager,
                                           future.GetRepeatingCallback(),
                                           InstallableWebAppCheckResult::kNo);
  ASSERT_TRUE(content::NavigateToURL(web_contents(), kInnerAppUrl));

  ASSERT_TRUE(future.Wait());
  EXPECT_EQ(kInnerAppUrl, future.Get());
}

#endif  // !BUILDFLAG(IS_ANDROID)

INSTANTIATE_TEST_SUITE_P(All,
                         AppBannerManagerBrowserTest,
                         ::testing::Values(CheckWebAppExistence::kAsync,
                                           CheckWebAppExistence::kSync));
}  // namespace
}  // namespace webapps