// Copyright 2018 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/web_applications/externally_managed_app_manager.h"

#include <algorithm>
#include <iterator>
#include <optional>
#include <sstream>
#include <vector>

#include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/bind.h"
#include "base/test/test_future.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/apps/app_service/publishers/app_publisher.h"
#include "chrome/browser/web_applications/external_install_options.h"
#include "chrome/browser/web_applications/externally_managed_app_manager.h"
#include "chrome/browser/web_applications/mojom/user_display_mode.mojom-shared.h"
#include "chrome/browser/web_applications/mojom/user_display_mode.mojom.h"
#include "chrome/browser/web_applications/policy/web_app_policy_manager.h"
#include "chrome/browser/web_applications/test/fake_web_app_provider.h"
#include "chrome/browser/web_applications/test/fake_web_contents_manager.h"
#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
#include "chrome/browser/web_applications/test/web_app_test.h"
#include "chrome/browser/web_applications/test/web_app_test_utils.h"
#include "chrome/browser/web_applications/web_app.h"
#include "chrome/browser/web_applications/web_app_constants.h"
#include "chrome/browser/web_applications/web_app_helpers.h"
#include "chrome/browser/web_applications/web_app_management_type.h"
#include "chrome/browser/web_applications/web_app_provider.h"
#include "chrome/browser/web_applications/web_app_registrar.h"
#include "chrome/browser/web_applications/web_app_registry_update.h"
#include "chrome/browser/web_applications/web_app_sync_bridge.h"
#include "chrome/common/chrome_features.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "components/webapps/browser/install_result_code.h"
#include "components/webapps/browser/web_contents/web_app_url_loader.h"
#include "components/webapps/common/web_page_metadata.mojom.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/mojom/manifest/display_mode.mojom-shared.h"
#include "third_party/blink/public/mojom/manifest/manifest.mojom-forward.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace web_app {

namespace {

int GetInstallCountsFromResult(
    const std::map<GURL, ExternallyManagedAppManager::InstallResult>&
        install_results,
    bool include_duplicates = false) {
  int count = 0;
  for (const auto& result : install_results) {
    if (result.second.code == webapps::InstallResultCode::kSuccessNewInstall ||
        (include_duplicates &&
         result.second.code ==
             webapps::InstallResultCode::kSuccessAlreadyInstalled)) {
      count++;
    }
  }
  return count;
}

}  // namespace

class ExternallyManagedAppManagerTest : public WebAppTest {
 public:
  ExternallyManagedAppManagerTest() = default;

 protected:
  void SetUp() override {
    WebAppTest::SetUp();
    provider_ = web_app::FakeWebAppProvider::Get(profile());
    web_app::test::AwaitStartWebAppProviderAndSubsystems(profile());
  }

  void ForceSystemShutdown() { provider_->Shutdown(); }

  void Sync(const std::vector<GURL>& urls, bool include_duplicates = false) {
    ResetCounts();

    std::vector<ExternalInstallOptions> install_options_list;
    install_options_list.reserve(urls.size());
    for (const auto& url : urls) {
      install_options_list.emplace_back(
          url, mojom::UserDisplayMode::kStandalone,
          ExternalInstallSource::kInternalDefault);
    }

    base::RunLoop run_loop;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        std::move(install_options_list),
        ExternalInstallSource::kInternalDefault,
        base::BindLambdaForTesting(
            [&](std::map<GURL, ExternallyManagedAppManager::InstallResult>
                    install_results,
                std::map<GURL, webapps::UninstallResultCode>
                    uninstall_results) {
              install_count_ = GetInstallCountsFromResult(install_results,
                                                          include_duplicates);
              uninstall_count_ = uninstall_results.size();
              run_loop.Quit();
            }));
    // Wait for SynchronizeInstalledApps to finish.
    run_loop.Run();
  }

  void Expect(int install_count,
              int uninstall_count,
              const std::vector<GURL>& installed_app_urls) {
    EXPECT_EQ(install_count, install_count_);
    EXPECT_EQ(uninstall_count, uninstall_count_);
    base::flat_map<webapps::AppId, base::flat_set<GURL>> apps =
        app_registrar().GetExternallyInstalledApps(
            ExternalInstallSource::kInternalDefault);
    std::vector<GURL> urls;
    for (const auto& it : apps) {
      std::ranges::copy(it.second, std::back_inserter(urls));
    }

    std::sort(urls.begin(), urls.end());
    EXPECT_EQ(installed_app_urls, urls);
  }

  void ResetCounts() {
    install_count_ = 0;
    uninstall_count_ = 0;
  }

  WebAppProvider& provider() { return *provider_; }

  WebAppRegistrar& app_registrar() { return provider().registrar_unsafe(); }

 private:
  int install_count_ = 0;
  int uninstall_count_ = 0;

  raw_ptr<FakeWebAppProvider, DanglingUntriaged> provider_ = nullptr;
};

// Test that destroying ExternallyManagedAppManager during a synchronize call
// that installs an app doesn't crash. Regression test for
// https://crbug.com/962808
TEST_F(ExternallyManagedAppManagerTest, DestroyDuringInstallInSynchronize) {
  std::vector<ExternalInstallOptions> install_options_list;
  install_options_list.emplace_back(GURL("https://foo.example"),
                                    mojom::UserDisplayMode::kStandalone,
                                    ExternalInstallSource::kInternalDefault);
  install_options_list.emplace_back(GURL("https://bar.example"),
                                    mojom::UserDisplayMode::kStandalone,
                                    ExternalInstallSource::kInternalDefault);

  provider().externally_managed_app_manager().SynchronizeInstalledApps(
      std::move(install_options_list), ExternalInstallSource::kInternalDefault,
      // ExternallyManagedAppManager gives no guarantees about whether its
      // pending callbacks will be run or not when it gets destroyed.
      base::DoNothing());
  ForceSystemShutdown();
  base::RunLoop().RunUntilIdle();
}

// Test that destroying ExternallyManagedAppManager during a synchronize call
// that uninstalls an app doesn't crash. Regression test for
// https://crbug.com/962808
TEST_F(ExternallyManagedAppManagerTest, DestroyDuringUninstallInSynchronize) {
  // Install an app that will be uninstalled next.
  {
    std::vector<ExternalInstallOptions> install_options_list;
    install_options_list.emplace_back(GURL("https://foo.example"),
                                      mojom::UserDisplayMode::kStandalone,
                                      ExternalInstallSource::kInternalDefault);
    base::RunLoop run_loop;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        std::move(install_options_list),
        ExternalInstallSource::kInternalDefault,
        base::BindLambdaForTesting(
            [&](std::map<GURL, ExternallyManagedAppManager::InstallResult>
                    install_results,
                std::map<GURL, webapps::UninstallResultCode>
                    uninstall_results) { run_loop.Quit(); }));
    run_loop.Run();
  }

  provider().externally_managed_app_manager().SynchronizeInstalledApps(
      std::vector<ExternalInstallOptions>(),
      ExternalInstallSource::kInternalDefault,
      // ExternallyManagedAppManager gives no guarantees about whether its
      // pending callbacks will be run or not when it gets destroyed.
      base::DoNothing());
  ForceSystemShutdown();
  base::RunLoop().RunUntilIdle();
}

TEST_F(ExternallyManagedAppManagerTest, SynchronizeInstalledApps) {
  GURL a("https://a.example.com/");
  GURL b("https://b.example.com/");
  GURL c("https://c.example.com/");
  GURL d("https://d.example.com/");
  GURL e("https://e.example.com/");

  FakeWebContentsManager& web_contents_manager =
      static_cast<FakeWebContentsManager&>(provider().web_contents_manager());
  web_contents_manager.CreateBasicInstallPageState(a, a, a);
  web_contents_manager.CreateBasicInstallPageState(b, b, b);
  web_contents_manager.CreateBasicInstallPageState(c, c, c);
  web_contents_manager.CreateBasicInstallPageState(d, d, d);
  web_contents_manager.CreateBasicInstallPageState(e, e, e);

  Sync(std::vector<GURL>{a, b, d});
  Expect(3, 0, std::vector<GURL>{a, b, d});

  Sync(std::vector<GURL>{b, e});
  Expect(1, 2, std::vector<GURL>{b, e});

  Sync(std::vector<GURL>{e});
  Expect(0, 1, std::vector<GURL>{e});

  Sync(std::vector<GURL>{c});
  Expect(1, 1, std::vector<GURL>{c});

  Sync(std::vector<GURL>{e, a, d});
  Expect(3, 1, std::vector<GURL>{a, d, e});

  Sync(std::vector<GURL>{c, a, b, d, e});
  Expect(2, 0, std::vector<GURL>{a, b, c, d, e});

  Sync(std::vector<GURL>{});
  Expect(0, 5, std::vector<GURL>{});

  // The remaining code tests duplicate inputs.
  Sync(std::vector<GURL>{b, a, b, c}, /*include_duplicates=*/true);
  Expect(3, 0, std::vector<GURL>{a, b, c});

  Sync(std::vector<GURL>{e, a, e, e, e, a}, /*include_duplicates=*/true);
  Expect(2, 2, std::vector<GURL>{a, e});

  Sync(std::vector<GURL>{b, c, d}, /*include_duplicates=*/true);
  Expect(3, 2, std::vector<GURL>{b, c, d});

  Sync(std::vector<GURL>{a, a, a, a, a, a}, /*include_duplicates=*/true);
  Expect(1, 3, std::vector<GURL>{a});

  Sync(std::vector<GURL>{}, /*include_duplicates=*/true);
  Expect(0, 1, std::vector<GURL>{});
}

namespace {

using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::IsEmpty;
using ::testing::UnorderedElementsAre;

std::unique_ptr<WebAppInstallInfo> GetWebAppInstallInfo(const GURL& url) {
  std::unique_ptr<WebAppInstallInfo> info =
      WebAppInstallInfo::CreateWithStartUrlForTesting(url);
  info->scope = url.GetWithoutFilename();
  info->title = u"Web App";
  return info;
}

// Test harness that keep the system as real as possible.
class ExternallyAppManagerTest : public WebAppTest {
 public:
  using InstallResults = std::map<GURL /*install_url*/,
                                  ExternallyManagedAppManager::InstallResult>;
  using UninstallResults =
      std::map<GURL /*install_url*/, webapps::UninstallResultCode>;
  using SynchronizeFuture =
      base::test::TestFuture<InstallResults, UninstallResults>;
  using InstallNowFuture =
      base::test::TestFuture<const GURL&,
                             ExternallyManagedAppManager::InstallResult>;

  ExternallyAppManagerTest() = default;

  void SetUp() override {
    WebAppTest::SetUp();
    // TODO(http://b/278922549): Disable the external management apps so we
    // don't compete with the policy app manager for our installs /
    // synchronization.
    web_app::test::AwaitStartWebAppProviderAndSubsystems(profile());
  }

  std::vector<ExternalInstallOptions> CreateExternalInstallOptionsFromTemplate(
      std::vector<GURL> install_urls,
      ExternalInstallSource source,
      std::optional<ExternalInstallOptions> template_options = std::nullopt) {
    std::vector<ExternalInstallOptions> output;
    std::ranges::transform(
        install_urls, std::back_inserter(output),
        [source, &template_options](const GURL& install_url) {
          ExternalInstallOptions options = template_options.value_or(
              ExternalInstallOptions(install_url, std::nullopt, source));
          options.install_url = install_url;
          options.install_source = source;
          return options;
        });
    return output;
  }

  ExternalInstallOptions CreateExternalInstallOptionsWithAppInfo(
      GURL install_url,
      ExternalInstallSource source) {
    ExternalInstallOptions options(install_url,
                                   mojom::UserDisplayMode::kBrowser, source);
    options.app_info_factory =
        base::BindRepeating(&GetWebAppInstallInfo, install_url);
    return options;
  }

  WebAppProvider& provider() { return *WebAppProvider::GetForTest(profile()); }

  WebAppRegistrar& app_registrar() { return provider().registrar_unsafe(); }

  ExternallyManagedAppManager& external_manager() {
    return provider().externally_managed_app_manager();
  }

  FakeWebContentsManager& web_contents_manager() {
    return static_cast<FakeWebContentsManager&>(
        provider().web_contents_manager());
  }
};

TEST_F(ExternallyAppManagerTest, NoNetworkNoPlaceholder) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");

  // Not populating the `FakeWebContentsManager` means it treats the network as
  // non-functional / not available.

  SynchronizeFuture result;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl}, ExternalInstallSource::kExternalPolicy),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // Empty uninstall results.
  EXPECT_THAT(result.Get<UninstallResults>(), IsEmpty());

  // Install should have failed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(install_results,
              ElementsAre(std::make_pair(
                  kInstallUrl,
                  ExternallyManagedAppManager::InstallResult(
                      webapps::InstallResultCode::kInstallURLLoadFailed))));
}

TEST_F(ExternallyAppManagerTest, SimpleInstall) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  SynchronizeFuture result;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl}, ExternalInstallSource::kExternalPolicy),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // Empty uninstall results.
  EXPECT_THAT(result.Get<UninstallResults>(), IsEmpty());

  // Install should succeed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(
      install_results,
      ElementsAre(std::make_pair(
          kInstallUrl,
          ExternallyManagedAppManager::InstallResult(
              webapps::InstallResultCode::kSuccessNewInstall, app_id))));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_SimpleInstallWebAppInfo DISABLED_SimpleInstallWebAppInfo
#else
#define MAYBE_SimpleInstallWebAppInfo SimpleInstallWebAppInfo
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_SimpleInstallWebAppInfo) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  InstallNowFuture future;
  external_manager().InstallNow(
      CreateExternalInstallOptionsWithAppInfo(
          kInstallUrl, ExternalInstallSource::kExternalPolicy),
      future.GetCallback());
  ASSERT_TRUE(future.Wait());

  // Install should succeed.
  ExternallyManagedAppManager::InstallResult result =
      future.Get<ExternallyManagedAppManager::InstallResult>();
  EXPECT_EQ(result,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_MultipleInstallWebAppInfoInstallUrl \
  DISABLED_MultipleInstallWebAppInfoInstallUrl
#else
#define MAYBE_MultipleInstallWebAppInfoInstallUrl \
  MultipleInstallWebAppInfoInstallUrl
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_MultipleInstallWebAppInfoInstallUrl) {
  const GURL kStartUrl1 = GURL("https://www.example1.com/index.html");
  const GURL kInstallUrl1 =
      GURL("https://www.example1.com/nested/install_url.html");
  const GURL kManifestUrl1 = GURL("https://www.example1.com/manifest.json");

  const GURL kStartUrl2 = GURL("https://www.example2.com/index.html");
  const GURL kInstallUrl2 =
      GURL("https://www.example2.com/nested/install_url.html");
  const GURL kManifestUrl2 = GURL("https://www.example2.com/manifest.json");

  webapps::AppId app_id1 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl1, kManifestUrl1, kStartUrl1);

  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl2, kManifestUrl2, kStartUrl2);

  InstallNowFuture future1;
  InstallNowFuture future2;
  external_manager().InstallNow(
      CreateExternalInstallOptionsWithAppInfo(
          kInstallUrl1, ExternalInstallSource::kExternalDefault),
      future1.GetCallback());
  external_manager().InstallNow(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl2}, ExternalInstallSource::kExternalPolicy)[0],
      future2.GetCallback());
  ASSERT_TRUE(future1.Wait());
  ASSERT_TRUE(future2.Wait());

  // Both installs should succeed.
  ExternallyManagedAppManager::InstallResult result1 =
      future1.Get<ExternallyManagedAppManager::InstallResult>();
  ExternallyManagedAppManager::InstallResult result2 =
      future2.Get<ExternallyManagedAppManager::InstallResult>();

  EXPECT_EQ(result1,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id1));
  EXPECT_EQ(result2,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id2));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_InstallWebAppInfoTwiceAlreadyInstalled \
  DISABLED_InstallWebAppInfoTwiceAlreadyInstalled
#else
#define MAYBE_InstallWebAppInfoTwiceAlreadyInstalled \
  InstallWebAppInfoTwiceAlreadyInstalled
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_InstallWebAppInfoTwiceAlreadyInstalled) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  InstallNowFuture future1;
  InstallNowFuture future2;
  external_manager().Install(
      CreateExternalInstallOptionsWithAppInfo(
          kInstallUrl, ExternalInstallSource::kExternalDefault),
      future1.GetCallback());
  external_manager().Install(
      CreateExternalInstallOptionsWithAppInfo(
          kInstallUrl, ExternalInstallSource::kExternalDefault),
      future2.GetCallback());
  ASSERT_TRUE(future1.Wait());
  ASSERT_TRUE(future2.Wait());

  // Both installs should succeed, with the 2nd one returning a
  // `kSuccessAlreadyInstalled` result.
  ExternallyManagedAppManager::InstallResult result1 =
      future1.Get<ExternallyManagedAppManager::InstallResult>();
  ExternallyManagedAppManager::InstallResult result2 =
      future2.Get<ExternallyManagedAppManager::InstallResult>();

  EXPECT_EQ(result1,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id));
  EXPECT_EQ(result2,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessAlreadyInstalled, app_id));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_InstallOptionsTwiceForReinstall \
  DISABLED_InstallOptionsTwiceForReinstall
#else
#define MAYBE_InstallOptionsTwiceForReinstall InstallOptionsTwiceForReinstall
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_InstallOptionsTwiceForReinstall) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  ExternalInstallOptions options = CreateExternalInstallOptionsFromTemplate(
      {kInstallUrl}, ExternalInstallSource::kExternalPolicy)[0];
  options.force_reinstall = true;

  InstallNowFuture future1;
  InstallNowFuture future2;
  external_manager().Install(options, future1.GetCallback());
  external_manager().Install(options, future2.GetCallback());
  ASSERT_TRUE(future1.Wait());
  ASSERT_TRUE(future2.Wait());

  // Both installs should succeed, with the 2nd one returning a
  // `kSuccessNewInstall` result because of the `force_reinstall` flag.
  ExternallyManagedAppManager::InstallResult result1 =
      future1.Get<ExternallyManagedAppManager::InstallResult>();
  ExternallyManagedAppManager::InstallResult result2 =
      future2.Get<ExternallyManagedAppManager::InstallResult>();

  EXPECT_EQ(result1,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id));
  EXPECT_EQ(result2,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_InstallReentrantCallback DISABLED_InstallReentrantCallback
#else
#define MAYBE_InstallReentrantCallback InstallReentrantCallback
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_InstallReentrantCallback) {
  const GURL kStartUrl1 = GURL("https://www.example1.com/index.html");
  const GURL kInstallUrl1 =
      GURL("https://www.example1.com/nested/install_url.html");
  const GURL kManifestUrl1 = GURL("https://www.example1.com/manifest.json");

  const GURL kStartUrl2 = GURL("https://www.example2.com/index.html");
  const GURL kInstallUrl2 =
      GURL("https://www.example2.com/nested/install_url.html");
  const GURL kManifestUrl2 = GURL("https://www.example2.com/manifest.json");

  webapps::AppId app_id1 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl1, kManifestUrl1, kStartUrl1);

  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl2, kManifestUrl2, kStartUrl2);

  InstallNowFuture inside_future;
  ExternallyManagedAppManager::InstallResult external_result;
  external_manager().InstallNow(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl1}, ExternalInstallSource::kExternalPolicy)[0],
      base::BindLambdaForTesting(
          [&](const GURL& url,
              ExternallyManagedAppManager::InstallResult result) {
            // Verify the first installation has succeeded.
            EXPECT_EQ(
                result,
                ExternallyManagedAppManager::InstallResult(
                    webapps::InstallResultCode::kSuccessNewInstall, app_id1));
            external_manager().InstallNow(
                CreateExternalInstallOptionsFromTemplate(
                    {kInstallUrl2}, ExternalInstallSource::kExternalPolicy)[0],
                inside_future.GetCallback());
          }));
  ASSERT_TRUE(inside_future.Wait());

  // The intermediary install inside the callback should succeed.
  ExternallyManagedAppManager::InstallResult result =
      inside_future.Get<ExternallyManagedAppManager::InstallResult>();
  EXPECT_EQ(result,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id2));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_MultipleAppsInstallSerial DISABLED_MultipleAppsInstallSerial
#else
#define MAYBE_MultipleAppsInstallSerial MultipleAppsInstallSerial
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_MultipleAppsInstallSerial) {
  const GURL kStartUrl1 = GURL("https://www.example.com/index1.html");
  const GURL kInstallUrl1 =
      GURL("https://www.example.com/nested/install_url1.html");
  const GURL kManifestUrl1 = GURL("https://www.example.com/manifest1.json");

  webapps::AppId app_id1 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl1, kManifestUrl1, kStartUrl1);

  SynchronizeFuture result1;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl1}, ExternalInstallSource::kExternalPolicy),
      ExternalInstallSource::kExternalPolicy, result1.GetCallback());
  ASSERT_TRUE(result1.Wait());

  // Empty uninstall results.
  EXPECT_THAT(result1.Get<UninstallResults>(), IsEmpty());

  // Install should succeed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results1 =
      result1.Get<InstallResults>();
  EXPECT_THAT(
      install_results1,
      ElementsAre(std::make_pair(
          kInstallUrl1,
          ExternallyManagedAppManager::InstallResult(
              webapps::InstallResultCode::kSuccessNewInstall, app_id1))));

  const GURL kStartUrl2 = GURL("https://www.example2.com/index.html");
  const GURL kInstallUrl2 =
      GURL("https://www.example2.com/nested/install_url.html");
  const GURL kManifestUrl2 = GURL("https://www.example2.com/manifest.json");

  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl2, kManifestUrl2, kStartUrl2);

  SynchronizeFuture result2;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl2}, ExternalInstallSource::kExternalPolicy),
      ExternalInstallSource::kExternalPolicy, result2.GetCallback());
  ASSERT_TRUE(result2.Wait());

  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results2 =
      result2.Get<InstallResults>();
  EXPECT_THAT(
      install_results2,
      ElementsAre(std::make_pair(
          kInstallUrl2,
          ExternallyManagedAppManager::InstallResult(
              webapps::InstallResultCode::kSuccessNewInstall, app_id2))));
}

// TODO(crbug.com/405912587): Investigate and enable on Linux TSAN bots.
#if BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
#define MAYBE_PlaceholderAppWindowsClosed DISABLED_PlaceholderAppWindowsClosed
#else
#define MAYBE_PlaceholderAppWindowsClosed PlaceholderAppWindowsClosed
#endif  // BUILDFLAG(IS_LINUX) && defined(THREAD_SANITIZER)
TEST_F(ExternallyAppManagerTest, MAYBE_PlaceholderAppWindowsClosed) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  SynchronizeFuture result;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
          template_options),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // The webapps::AppId should be created from the install url.
  webapps::AppId app_id =
      GenerateAppId(/*manifest_id_path=*/std::nullopt, kInstallUrl);

  // Install should succeed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(
      install_results,
      ElementsAre(std::make_pair(
          kInstallUrl,
          ExternallyManagedAppManager::InstallResult(
              webapps::InstallResultCode::kSuccessNewInstall, app_id))));

  const WebApp* app = provider().registrar_unsafe().GetAppById(app_id);

  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(WebAppManagement::kPolicy,
                                         WebApp::ExternalManagementConfig(
                                             /*is_placeholder=*/true,
                                             /*install_urls=*/{kInstallUrl},
                                             /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest, TwoInstallUrlsSameApp) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl1 =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kInstallUrl2 =
      GURL("https://www.example.com/nested/install_url2.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl1, kManifestUrl, kStartUrl);
  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl2, kManifestUrl, kStartUrl);
  EXPECT_EQ(app_id, app_id2);

  SynchronizeFuture result;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl1, kInstallUrl2}, ExternalInstallSource::kExternalPolicy),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // Empty uninstall results.
  EXPECT_THAT(result.Get<UninstallResults>(), IsEmpty());

  // Installs should have both succeeded.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(
      install_results,
      UnorderedElementsAre(
          std::make_pair(
              kInstallUrl1,
              ExternallyManagedAppManager::InstallResult(
                  webapps::InstallResultCode::kSuccessNewInstall, app_id)),
          std::make_pair(
              kInstallUrl2,
              ExternallyManagedAppManager::InstallResult(
                  webapps::InstallResultCode::kSuccessNewInstall, app_id))));

  EXPECT_EQ(app_registrar().GetAppIds().size(), 1ul);
  const WebApp* app = app_registrar().GetAppById(app_id);
  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(
                  WebAppManagement::kPolicy,
                  WebApp::ExternalManagementConfig(
                      /*is_placeholder=*/false,
                      /*install_urls=*/{kInstallUrl1, kInstallUrl2},
                      /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest, RemovingInstallUrlsFromSource) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl1 =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kInstallUrl2 =
      GURL("https://www.example.com/nested/install_url2.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl1, kManifestUrl, kStartUrl);
  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl2, kManifestUrl, kStartUrl);
  EXPECT_EQ(app_id, app_id2);

  // Synchronize with 2 install URLs.
  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl1, kInstallUrl2},
            ExternalInstallSource::kExternalPolicy),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());

    // Empty uninstall results.
    EXPECT_THAT(result.Get<UninstallResults>(), IsEmpty());

    // Installs should have both succeeded.
    EXPECT_THAT(
        result.Get<InstallResults>(),
        UnorderedElementsAre(
            std::make_pair(
                kInstallUrl1,
                ExternallyManagedAppManager::InstallResult(
                    webapps::InstallResultCode::kSuccessNewInstall, app_id)),
            std::make_pair(
                kInstallUrl2,
                ExternallyManagedAppManager::InstallResult(
                    webapps::InstallResultCode::kSuccessNewInstall, app_id))));

    EXPECT_EQ(app_registrar().GetAppIds().size(), 1ul);
    const WebApp* app = app_registrar().GetAppById(app_id);
    ASSERT_TRUE(app);
    EXPECT_THAT(app->management_to_external_config_map(),
                ElementsAre(std::make_pair(
                    WebAppManagement::kPolicy,
                    WebApp::ExternalManagementConfig(
                        /*is_placeholder=*/false,
                        /*install_urls=*/{kInstallUrl1, kInstallUrl2},
                        /*additional_policy_ids=*/{}))));
  }

  // Synchronize with 1 install URL.
  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl1}, ExternalInstallSource::kExternalPolicy),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());

    // Empty install results.
    EXPECT_THAT(result.Get<InstallResults>(),
                UnorderedElementsAre(std::make_pair(
                    kInstallUrl1,
                    ExternallyManagedAppManager::InstallResult(
                        webapps::InstallResultCode::kSuccessAlreadyInstalled,
                        app_id))));

    // One install URL uninstalled.
    EXPECT_THAT(
        result.Get<UninstallResults>(),
        UnorderedElementsAre(std::make_pair(
            kInstallUrl2, webapps::UninstallResultCode::kInstallUrlRemoved)));

    EXPECT_EQ(app_registrar().GetAppIds().size(), 1ul);
    const WebApp* app = app_registrar().GetAppById(app_id);
    ASSERT_TRUE(app);
    EXPECT_THAT(app->management_to_external_config_map(),
                ElementsAre(std::make_pair(WebAppManagement::kPolicy,
                                           WebApp::ExternalManagementConfig(
                                               /*is_placeholder=*/false,
                                               /*install_urls=*/{kInstallUrl1},
                                               /*additional_policy_ids=*/{}))));
  }

  // Synchronize with 0 install URLs.
  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {}, ExternalInstallSource::kExternalPolicy),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());

    // Empty install results.
    EXPECT_THAT(result.Get<InstallResults>(), IsEmpty());

    // One install URL uninstalled.
    EXPECT_THAT(result.Get<UninstallResults>(),
                UnorderedElementsAre(std::make_pair(
                    kInstallUrl1, webapps::UninstallResultCode::kAppRemoved)));

    // App should be cleaned up.
    EXPECT_EQ(app_registrar().GetAppIds().size(), 0ul);
    const WebApp* app = app_registrar().GetAppById(app_id);
    ASSERT_FALSE(app);
  }
}

TEST_F(ExternallyAppManagerTest, InstallUrlChanges) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kInstallUrl2 =
      GURL("https://www.example.com/nested/install_url2.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);
  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl2, kManifestUrl, kStartUrl);
  EXPECT_EQ(app_id, app_id2);

  // First synchronize will install the app.
  {
    SynchronizeFuture result;
    external_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kExternalPolicy),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());

    std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
        result.Get<InstallResults>();
    EXPECT_THAT(
        install_results,
        ElementsAre(std::make_pair(
            kInstallUrl,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id))));
  }

  // Second synchronize with a different install url should succeed and update
  // the install urls correctly.
  {
    SynchronizeFuture result;
    external_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl2}, ExternalInstallSource::kExternalPolicy),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());
    std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
        result.Get<InstallResults>();
    EXPECT_THAT(
        install_results,
        ElementsAre(std::make_pair(
            kInstallUrl2,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id))));

    ASSERT_THAT(result.Get<UninstallResults>(),
                testing::UnorderedElementsAre(std::make_pair(
                    kInstallUrl, webapps::UninstallResultCode::kAppRemoved)));
  }

  const WebApp* app = provider().registrar_unsafe().GetAppById(app_id);
  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(WebAppManagement::kPolicy,
                                         WebApp::ExternalManagementConfig(
                                             /*is_placeholder=*/false,
                                             /*install_urls=*/{kInstallUrl2},
                                             /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest, PolicyAppOverridesUserInstalledApp) {
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kInstallUrl =
      GURL("https://www.example.com/nested/install_url.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  {
    // Install user app
    auto& install_page_state =
        web_contents_manager().GetOrCreatePageState(kInstallUrl);
    install_page_state.manifest_before_default_processing->short_name =
        u"Test user app";

    auto install_info =
        WebAppInstallInfo::CreateWithStartUrlForTesting(kStartUrl);
    install_info->title = u"Test user app";
    std::optional<webapps::AppId> user_app_id =
        test::InstallWebApp(profile(), std::move(install_info));

    ASSERT_TRUE(user_app_id.has_value());
    ASSERT_EQ(user_app_id.value(), app_id);
    ASSERT_TRUE(app_registrar().WasInstalledByUser(app_id));
    ASSERT_FALSE(app_registrar().HasExternalApp(app_id));
    ASSERT_EQ("Test user app", app_registrar().GetAppShortName(app_id));
  }
  {
    // Install policy app
    auto& install_page_state =
        web_contents_manager().GetOrCreatePageState(kInstallUrl);
    install_page_state.manifest_before_default_processing->short_name =
        u"Test policy app";

    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kExternalPolicy),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());
    std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
        result.Get<InstallResults>();
    EXPECT_THAT(
        install_results,
        ElementsAre(std::make_pair(
            kInstallUrl,
            ExternallyManagedAppManager::InstallResult(
                webapps::InstallResultCode::kSuccessNewInstall, app_id))));
    ASSERT_EQ("Test policy app", app_registrar().GetAppShortName(app_id));
  }
}

TEST_F(ExternallyAppManagerTest, NoNetworkWithPlaceholder) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  SynchronizeFuture result;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
          template_options),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // The webapps::AppId should be created from the install url.
  webapps::AppId app_id =
      GenerateAppId(/*manifest_id=*/std::nullopt, kInstallUrl);

  // Install should succeed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(
      install_results,
      ElementsAre(std::make_pair(
          kInstallUrl,
          ExternallyManagedAppManager::InstallResult(
              webapps::InstallResultCode::kSuccessNewInstall, app_id))));

  const WebApp* app = provider().registrar_unsafe().GetAppById(app_id);

  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(WebAppManagement::kPolicy,
                                         WebApp::ExternalManagementConfig(
                                             /*is_placeholder=*/true,
                                             /*install_urls=*/{kInstallUrl},
                                             /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest, RedirectInstallUrlPlaceholder) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  const GURL kRedirectToUrl =
      GURL("https://www.otherorigin.com/redirected.html");
  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  // Verify that a redirection causes a placeholder app to be installed.

  auto& page_state = web_contents_manager().GetOrCreatePageState(kInstallUrl);
  page_state.redirection_url = kRedirectToUrl;

  SynchronizeFuture result;
  external_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
          template_options),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // The webapps::AppId should be created from teh install url.
  webapps::AppId app_id =
      GenerateAppId(/*manifest_id=*/std::nullopt, kInstallUrl);

  // Install should succeed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(
      install_results,
      ElementsAre(std::make_pair(
          kInstallUrl,
          ExternallyManagedAppManager::InstallResult(
              webapps::InstallResultCode::kSuccessNewInstall, app_id))));

  const WebApp* app = provider().registrar_unsafe().GetAppById(app_id);
  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(WebAppManagement::kPolicy,
                                         WebApp::ExternalManagementConfig(
                                             /*is_placeholder=*/true,
                                             /*install_urls=*/{kInstallUrl},
                                             /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest, PlaceholderResolvedFromSynchronize) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  const GURL kRedirectToUrl =
      GURL("https://www.otherorigin.com/redirected.html");
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  auto& page_state = web_contents_manager().GetOrCreatePageState(kInstallUrl);
  page_state.redirection_url = kRedirectToUrl;
  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
            template_options),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());
  }

  webapps::AppId placeholder_app_id =
      GenerateAppId(/*manifest_id=*/std::nullopt, kInstallUrl);

  auto app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(placeholder_app_id));

  // Replace the redirect with an app that resolves.
  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  // The placeholder app should be uninstalled & the real one installed.
  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
            template_options),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());
  }

  app_ids = provider().registrar_unsafe().GetAppIds();

  EXPECT_THAT(app_ids, ElementsAre(app_id));
}

TEST_F(ExternallyAppManagerTest, PlaceholderResolvedFromInstallNow) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  const GURL kRedirectToUrl =
      GURL("https://www.otherorigin.com/redirected.html");
  const GURL kStartUrl = GURL("https://www.example.com/index.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest.json");

  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  auto& page_state = web_contents_manager().GetOrCreatePageState(kInstallUrl);
  page_state.redirection_url = kRedirectToUrl;
  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
            template_options),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());
  }

  webapps::AppId placeholder_app_id =
      GenerateAppId(/*manifest_id=*/std::nullopt, kInstallUrl);

  auto app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(placeholder_app_id));

  // Replace the redirect with an app that resolves.
  webapps::AppId app_id = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl, kStartUrl);

  ExternalInstallOptions options = template_options;
  options.install_url = kInstallUrl;
  options.placeholder_resolution_behavior =
      PlaceholderResolutionBehavior::kClose;
  InstallNowFuture install_future;
  provider().externally_managed_app_manager().InstallNow(
      std::move(options), install_future.GetCallback());
  ASSERT_TRUE(install_future.Wait());

  app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(app_id));
}

TEST_F(ExternallyAppManagerTest, TwoAppsSameInstallUrlSameSourceInstallNow) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  const GURL kStartUrl1 = GURL("https://www.example.com/index1.html");
  const GURL kStartUrl2 = GURL("https://www.example.com/index2.html");
  const GURL kManifestUrl1 = GURL("https://www.example.com/manifest1.json");
  const GURL kManifestUrl2 = GURL("https://www.example.com/manifest2.json");

  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);

  webapps::AppId app_id1 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl1, kStartUrl1);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl;
    base::test::TestFuture<const GURL&,
                           ExternallyManagedAppManager::InstallResult>
        install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
  }

  auto app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(app_id1));

  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl2, kStartUrl2);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl;
    InstallNowFuture install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
  }

  // TODO(crbug.com/40264854): This keeps the original app, but perhaps
  // should install app_id2.
  app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(app_id1));
}

TEST_F(ExternallyAppManagerTest, TwoAppsSameInstallUrlTwoSourcesInstallNow) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  const GURL kStartUrl1 = GURL("https://www.example.com/index1.html");
  const GURL kStartUrl2 = GURL("https://www.example.com/index2.html");
  const GURL kManifestUrl1 = GURL("https://www.example.com/manifest1.json");
  const GURL kManifestUrl2 = GURL("https://www.example.com/manifest2.json");

  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);

  webapps::AppId app_id1 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl1, kStartUrl1);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl;
    base::test::TestFuture<const GURL&,
                           ExternallyManagedAppManager::InstallResult>
        install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
  }

  auto app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(app_id1));

  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl2, kStartUrl2);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl;
    options.install_source = ExternalInstallSource::kInternalDefault;
    InstallNowFuture install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
  }

  // TODO(crbug.com/40264854): Currently, this keeps the original app,
  // but we should eventually resolve all apps to app_id2.
  app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(app_id1));
}

TEST_F(ExternallyAppManagerTest, TwoAppsSameInstallUrlTwoSourcesSynchronize) {
  const GURL kInstallUrl = GURL("https://www.example.com/install_url.html");
  const GURL kStartUrl1 = GURL("https://www.example.com/index1.html");
  const GURL kStartUrl2 = GURL("https://www.example.com/index2.html");
  const GURL kManifestUrl1 = GURL("https://www.example.com/manifest1.json");
  const GURL kManifestUrl2 = GURL("https://www.example.com/manifest2.json");

  ExternalInstallOptions template_options(
      kInstallUrl, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);

  webapps::AppId app_id1 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl1, kStartUrl1);

  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kExternalPolicy,
            template_options),
        ExternalInstallSource::kExternalPolicy, result.GetCallback());
    ASSERT_TRUE(result.Wait());
  }

  auto app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, ElementsAre(app_id1));

  webapps::AppId app_id2 = web_contents_manager().CreateBasicInstallPageState(
      kInstallUrl, kManifestUrl2, kStartUrl2);

  {
    SynchronizeFuture result;
    provider().externally_managed_app_manager().SynchronizeInstalledApps(
        CreateExternalInstallOptionsFromTemplate(
            {kInstallUrl}, ExternalInstallSource::kInternalDefault,
            template_options),
        ExternalInstallSource::kInternalDefault, result.GetCallback());
    ASSERT_TRUE(result.Wait());
  }

  // TODO(crbug.com/40264854): Currently this resolves to app_id1, but
  // should probably eventually resolve to app_id2.
  app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids, UnorderedElementsAre(app_id1));
}

TEST_F(ExternallyAppManagerTest, PlaceholderFixedBySecondInstallUrlInstallNow) {
  const GURL kInstallUrl1 = GURL("https://www.example.com/install_url1.html");
  const GURL kInstallUrl2 = GURL("https://www.example.com/install_url2.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest1.json");

  ExternalInstallOptions template_options(
      kInstallUrl1, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  // The first install creates a placeholder at kInstallUrl1, as that redirects.
  // The second install doesn't redirect, and the app at kInstallUrl2 points to
  // kInstallUrl1 as it's start_url (basically - it's identity conflicts with
  // the placeholder app's default identity).

  auto& page_state = web_contents_manager().GetOrCreatePageState(kInstallUrl1);
  page_state.redirection_url =
      GURL("https://www.otherorigin.com/redirect.html");

  webapps::AppId app_at_install_url =
      web_contents_manager().CreateBasicInstallPageState(
          kInstallUrl2, kManifestUrl, kInstallUrl1);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl1;
    InstallNowFuture install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
    EXPECT_THAT(
        install_future.Get(),
        Eq(std::make_tuple(kInstallUrl1,
                           ExternallyManagedAppManager::InstallResult(
                               webapps::InstallResultCode::kSuccessNewInstall,
                               app_at_install_url))));
  }

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl2;
    base::test::TestFuture<const GURL&,
                           ExternallyManagedAppManager::InstallResult>
        install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
    EXPECT_THAT(
        install_future.Get(),
        Eq(std::make_tuple(kInstallUrl2,
                           ExternallyManagedAppManager::InstallResult(
                               webapps::InstallResultCode::kSuccessNewInstall,
                               app_at_install_url))));
  }

  // The current implementation records placeholder information per-source, so
  // when the second install succeeds, it overrides the `is_placeholder` to
  // `false`, and thus the first install is considered fully installed now too.
  // This is in contrast to the behavior if the two installs are different
  // sources, which will (correctly?) evaluate the manifest served by the
  // install url of the first install, which could be a different app identity.
  const WebApp* app =
      provider().registrar_unsafe().GetAppById(app_at_install_url);
  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(
                  WebAppManagement::kPolicy,
                  WebApp::ExternalManagementConfig(
                      /*is_placeholder=*/false,
                      /*install_urls=*/{kInstallUrl1, kInstallUrl2},
                      /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest,
       PlaceholderFixedBySecondInstallUrlSynchronize) {
  const GURL kInstallUrl1 = GURL("https://www.example.com/install_url1.html");
  const GURL kInstallUrl2 = GURL("https://www.example.com/install_url2.html");
  const GURL kManifestUrl = GURL("https://www.example.com/manifest1.json");

  // The first install creates a placeholder at kInstallUrl1, as that redirects.
  // The second install doesn't redirect, and the app at kInstallUrl2 points to
  // kInstallUrl1 as it's start_url (basically - it's identity conflicts with
  // the placeholder app's default identity).

  ExternalInstallOptions template_options(
      kInstallUrl1, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  auto& page_state = web_contents_manager().GetOrCreatePageState(kInstallUrl1);
  page_state.redirection_url =
      GURL("https://www.otherorigin.com/redirect.html");

  webapps::AppId app_at_install_url =
      web_contents_manager().CreateBasicInstallPageState(
          kInstallUrl2, kManifestUrl, /*start_url=*/kInstallUrl1);

  SynchronizeFuture result;
  provider().externally_managed_app_manager().SynchronizeInstalledApps(
      CreateExternalInstallOptionsFromTemplate(
          {kInstallUrl1, kInstallUrl2}, ExternalInstallSource::kExternalPolicy,
          template_options),
      ExternalInstallSource::kExternalPolicy, result.GetCallback());
  ASSERT_TRUE(result.Wait());

  // Install should succeed.
  std::map<GURL, ExternallyManagedAppManager::InstallResult> install_results =
      result.Get<InstallResults>();
  EXPECT_THAT(
      install_results,
      UnorderedElementsAre(
          std::make_pair(kInstallUrl1,
                         ExternallyManagedAppManager::InstallResult(
                             webapps::InstallResultCode::kSuccessNewInstall,
                             app_at_install_url)),
          std::make_pair(kInstallUrl2,
                         ExternallyManagedAppManager::InstallResult(
                             webapps::InstallResultCode::kSuccessNewInstall,
                             app_at_install_url))));

  // The current implementation records placeholder information per-source, so
  // when the second install succeeds, it overrides the `is_placeholder` to
  // `false`, and thus the first install is considered fully installed now too.
  const WebApp* app =
      provider().registrar_unsafe().GetAppById(app_at_install_url);
  ASSERT_TRUE(app);
  EXPECT_THAT(app->management_to_external_config_map(),
              ElementsAre(std::make_pair(
                  WebAppManagement::kPolicy,
                  WebApp::ExternalManagementConfig(
                      /*is_placeholder=*/false,
                      /*install_urls=*/{kInstallUrl1, kInstallUrl2},
                      /*additional_policy_ids=*/{}))));
}

TEST_F(ExternallyAppManagerTest, PlaceholderFullInstallConflictCanUpdate) {
  // This test exists to test what happens when a placeholder install conflicts
  // with a another install from a different source, and then resolves to a
  // separate app entirely after the placeholder state is fixed.

  // Phase 1 configuration with redirect:
  // - kInstallUrl1 will redirect & generate a placeholder
  // - kInstallUrl2 will serve a manifest with kInstallUrl1 as the start_url

  // Phase 2 configuration - redirect removed
  // - kInstallUrl1 will serve a manifest with kStartUrl as the start_url.

  // What happens when resolving the placeholder at kInstallUrl1? Currently this
  // updates so that kStartUrl1 is installed.

  const GURL kInstallUrl1 = GURL("https://www.example.com/install_url1.html");
  const GURL kInstallUrl2 = GURL("https://www.example.com/install_url2.html");
  const GURL kStartUrl1 = GURL("https://www.example.com/index1.html");
  const GURL kManifestUrl1 = GURL("https://www.example.com/manifest1.json");
  const GURL kManifestUrl2 = GURL("https://www.example.com/manifest2.json");

  ExternalInstallOptions template_options(
      kInstallUrl1, mojom::UserDisplayMode::kStandalone,
      ExternalInstallSource::kExternalPolicy);
  template_options.install_placeholder = true;

  // Phase 1 state
  auto& page_state = web_contents_manager().GetOrCreatePageState(kInstallUrl1);
  page_state.redirection_url =
      GURL("https://www.otherorigin.com/redirect.html");

  webapps::AppId app_at_install_url =
      web_contents_manager().CreateBasicInstallPageState(
          kInstallUrl2, kManifestUrl1, kInstallUrl1);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl1;
    base::test::TestFuture<const GURL&,
                           ExternallyManagedAppManager::InstallResult>
        install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
    EXPECT_THAT(
        install_future.Get(),
        Eq(std::make_tuple(kInstallUrl1,
                           ExternallyManagedAppManager::InstallResult(
                               webapps::InstallResultCode::kSuccessNewInstall,
                               app_at_install_url))));
  }

  {
    ExternalInstallOptions options(kInstallUrl2,
                                   mojom::UserDisplayMode::kStandalone,
                                   ExternalInstallSource::kInternalDefault);
    base::test::TestFuture<const GURL&,
                           ExternallyManagedAppManager::InstallResult>
        install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());
    EXPECT_THAT(
        install_future.Get(),
        Eq(std::make_tuple(kInstallUrl2,
                           ExternallyManagedAppManager::InstallResult(
                               webapps::InstallResultCode::kSuccessNewInstall,
                               app_at_install_url))));
  }

  const WebApp* app =
      provider().registrar_unsafe().GetAppById(app_at_install_url);
  ASSERT_TRUE(app);
  EXPECT_THAT(
      app->management_to_external_config_map(),
      UnorderedElementsAre(std::make_pair(WebAppManagement::kPolicy,
                                          WebApp::ExternalManagementConfig(
                                              /*is_placeholder=*/true,
                                              /*install_urls=*/{kInstallUrl1},
                                              /*additional_policy_ids=*/{})),
                           std::make_pair(WebAppManagement::kDefault,
                                          WebApp::ExternalManagementConfig(
                                              /*is_placeholder=*/false,
                                              /*install_urls=*/{kInstallUrl2},
                                              /*additional_policy_ids=*/{}))));
  // Phase 2 - undo the redirection, and point to start url.
  webapps::AppId app_at_start_url =
      web_contents_manager().CreateBasicInstallPageState(
          kInstallUrl1, kManifestUrl2, kStartUrl1);

  {
    ExternalInstallOptions options = template_options;
    options.install_url = kInstallUrl1;
    base::test::TestFuture<const GURL&,
                           ExternallyManagedAppManager::InstallResult>
        install_future;
    provider().externally_managed_app_manager().InstallNow(
        std::move(options), install_future.GetCallback());
    ASSERT_TRUE(install_future.Wait());

    EXPECT_THAT(
        install_future.Get(),
        Eq(std::make_tuple(kInstallUrl1,
                           ExternallyManagedAppManager::InstallResult(
                               webapps::InstallResultCode::kSuccessNewInstall,
                               app_at_start_url))));
  }

  // This is the current behavior, but it could change if we decide that
  // 'placeholder' is a per-app state instead of a per-app-and-source state.
  auto app_ids = provider().registrar_unsafe().GetAppIds();
  EXPECT_THAT(app_ids,
              UnorderedElementsAre(app_at_install_url, app_at_start_url));
}

}  // namespace
}  // namespace web_app