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

#include "chrome/browser/ui/webui/browser_switch/browser_switch_ui.h"

#include <memory>
#include <string_view>

#include "base/containers/to_value_list.h"
#include "base/functional/bind.h"
#include "base/i18n/time_formatting.h"
#include "base/json/json_writer.h"
#include "base/metrics/histogram_macros.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "base/values.h"
#include "chrome/browser/browser_switcher/alternative_browser_driver.h"
#include "chrome/browser/browser_switcher/browser_switcher_prefs.h"
#include "chrome/browser/browser_switcher/browser_switcher_service_factory.h"
#include "chrome/browser/browser_switcher/browser_switcher_sitelist.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_window/public/browser_window_interface.h"
#include "chrome/browser/ui/browser_window/public/browser_window_interface_iterator.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/webui_url_constants.h"
#include "chrome/grit/branded_strings.h"
#include "chrome/grit/browser_switch_resources.h"
#include "chrome/grit/browser_switch_resources_map.h"
#include "chrome/grit/generated_resources.h"
#include "components/grit/components_resources.h"
#include "components/policy/core/common/policy_pref_names.h"
#include "components/policy/policy_constants.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/page_navigator.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_ui.h"
#include "content/public/browser/web_ui_data_source.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/page_transition_types.h"
#include "ui/webui/webui_util.h"
#include "url/gurl.h"

namespace {

void GotoNewTabPage(content::WebContents* web_contents) {
  GURL url(chrome::kChromeUINewTabURL);
  content::OpenURLParams params(url, content::Referrer(),
                                WindowOpenDisposition::CURRENT_TAB,
                                ui::PAGE_TRANSITION_AUTO_TOPLEVEL, false);
  web_contents->OpenURL(params, /*navigation_handle_callback=*/{});
}

// Returns true if there's only 1 tab left open in this profile. Incognito
// window tabs count as the same profile.
bool IsLastTab(const Profile* profile) {
  profile = profile->GetOriginalProfile();
  int tab_count = 0;
  ForEachCurrentBrowserWindowInterfaceOrderedByActivation(
      [profile, &tab_count](BrowserWindowInterface* browser) {
        if (browser->GetProfile()->GetOriginalProfile() != profile) {
          return true;
        }
        tab_count += browser->GetTabStripModel()->count();
        return tab_count <= 1;  // Continue only if we haven't found 2+ tabs yet
      });
  return tab_count <= 1;
}

// Returns a dictionary like:
//
// {
//   "sitelist": ["example.com", ...],
//   "greylist": ["example.net", ...]
// }
base::Value::Dict RuleSetToDict(const browser_switcher::RuleSet& ruleset) {
  base::Value::List sitelist;
  for (const auto& rule : ruleset.sitelist) {
    sitelist.Append(rule->ToString());
  }

  base::Value::List greylist;
  for (const auto& rule : ruleset.greylist) {
    greylist.Append(rule->ToString());
  }

  return base::Value::Dict()
      .Set("sitelist", std::move(sitelist))
      .Set("greylist", std::move(greylist));
}

browser_switcher::BrowserSwitcherService* GetBrowserSwitcherService(
    content::WebUI* web_ui) {
  return browser_switcher::BrowserSwitcherServiceFactory::GetForBrowserContext(
      web_ui->GetWebContents()->GetBrowserContext());
}

void CreateAndAddBrowserSwitchUIHTMLSource(content::WebUI* web_ui) {
  content::WebUIDataSource* source = content::WebUIDataSource::CreateAndAdd(
      Profile::FromWebUI(web_ui), chrome::kChromeUIBrowserSwitchHost);

  auto* service = GetBrowserSwitcherService(web_ui);
  source->AddInteger("launchDelay", service->prefs().GetDelay());

  std::string alt_browser_name = service->driver()->GetBrowserName();
  source->AddString("altBrowserName", alt_browser_name);

  source->AddLocalizedString("browserName", IDS_PRODUCT_NAME);

  if (alt_browser_name.empty()) {
    // Browser name could not be auto-detected. Say "alternative browser"
    // instead of naming the browser.
    source->AddLocalizedString(
        "countdownTitle",
        IDS_ABOUT_BROWSER_SWITCH_COUNTDOWN_TITLE_UNKNOWN_BROWSER);
    source->AddLocalizedString(
        "description", IDS_ABOUT_BROWSER_SWITCH_DESCRIPTION_UNKNOWN_BROWSER);
    source->AddLocalizedString(
        "errorTitle", IDS_ABOUT_BROWSER_SWITCH_ERROR_TITLE_UNKNOWN_BROWSER);
    source->AddLocalizedString(
        "genericError", IDS_ABOUT_BROWSER_SWITCH_GENERIC_ERROR_UNKNOWN_BROWSER);
    source->AddLocalizedString(
        "openingTitle", IDS_ABOUT_BROWSER_SWITCH_OPENING_TITLE_UNKNOWN_BROWSER);
  } else {
    // Browser name was auto-detected. Name it in the text.
    source->AddLocalizedString(
        "countdownTitle",
        IDS_ABOUT_BROWSER_SWITCH_COUNTDOWN_TITLE_KNOWN_BROWSER);
    source->AddLocalizedString(
        "description", IDS_ABOUT_BROWSER_SWITCH_DESCRIPTION_KNOWN_BROWSER);
    source->AddLocalizedString(
        "errorTitle", IDS_ABOUT_BROWSER_SWITCH_ERROR_TITLE_KNOWN_BROWSER);
    source->AddLocalizedString(
        "genericError", IDS_ABOUT_BROWSER_SWITCH_GENERIC_ERROR_KNOWN_BROWSER);
    source->AddLocalizedString(
        "openingTitle", IDS_ABOUT_BROWSER_SWITCH_OPENING_TITLE_KNOWN_BROWSER);
  }

  static constexpr webui::LocalizedString kStrings[] = {
      {"switchInternalDescription", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_DESC},
      {"switchInternalTitle", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_TITLE},
      {"nothingShown", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_NOTHING_SHOWN},
      {"switcherDisabled", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_LBS_DISABLED},
      {"urlCheckerTitle", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_URL_CHECKER_TITLE},
      {"urlCheckerDesc", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_URL_CHECKER_DESC},
      {"openBrowser", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_OPEN_BROWSER},
      {"openBrowserProtocolReason",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_OPEN_BROWSER_PROTOCOL_REASON},
      {"openBrowserDefaultReason",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_OPEN_BROWSER_DEFAULT_REASON},
      {"openBrowserRuleReason",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_OPEN_BROWSER_RULE_REASON},
      {"openBrowserInvertRuleReason",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_OPEN_BROWSER_INVERT_RULE_REASON},
      {"invalidURL", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_INVALID_URL},
      {"xmlTitle", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_TITLE},
      {"xmlDesc", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_DESC},
      {"xmlSource", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_SOURCE},
      {"notConfigured", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_NOT_CONFIGURED},
      {"sitelistNotFetched",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_SITELIST_NOT_FETCHED},
      {"sitelistDownloadButton",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_SITELIST_DOWNLOAD_BUTTON},
      {"xmlSitelistLastDownloadDate",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_SITELIST_LAST_DOWNLOAD_DATE},
      {"xmlSitelistNextDownloadDate",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_XML_SITELIST_NEXT_DOWNLOAD_DATE},
      {"forceOpenTitle",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_IN_TITLE},
      {"forceOpenDescription",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_IN_DESCRIPTION},
      {"forceOpenParagraph1",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_IN_FIRST_PARAGRAPH},
      {"forceOpenParagraph2",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_IN_SECOND_PARAGRAPH},
      {"forceOpenTableColumnRule",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_TABLE_COLUMN_RULE},
      {"forceOpenTableColumnOpensIn",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_TABLE_COLUMN_OPENS_IN},
      {"forceOpenTableColumnSource",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_FORCE_OPEN_TABLE_COLUMN_SOURCE},
      {"ignoreTitle", IDS_ABOUT_BROWSER_SWITCH_INTERNALS_IGNORE_TITLE},
      {"ignoreDescription",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_IGNORE_DESCRIPTION},
      {"ignoreParagraph1",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_IGNORE_FIRST_PARAGRAPH},
      {"ignoreParagraph2",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_IGNORE_SECOND_PARAGRAPH},
      {"ignoreTableColumnRule",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_IGNORE_TABLE_COLUMN_RULE},
      {"ignoreTableColumnSource",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_IGNORE_TABLE_COLUMN_SOURCE},
      {"exportToJsonButton",
       IDS_ABOUT_BROWSER_SWITCH_INTERNALS_POLICIES_DOWNLOAD_BUTTON},
  };
  source->AddLocalizedStrings(kStrings);

  source->AddLocalizedString("protocolError",
                             IDS_ABOUT_BROWSER_SWITCH_PROTOCOL_ERROR);
  source->AddLocalizedString("title", IDS_ABOUT_BROWSER_SWITCH_TITLE);

  webui::SetupWebUIDataSource(source, kBrowserSwitchResources,
                              IDR_BROWSER_SWITCH_BROWSER_SWITCH_HTML);

  // Setup chrome://browser-switch/internals debug UI.
  source->AddResourcePath(
      "internals/", IDR_BROWSER_SWITCH_INTERNALS_BROWSER_SWITCH_INTERNALS_HTML);
  source->AddResourcePath(
      "internals", IDR_BROWSER_SWITCH_INTERNALS_BROWSER_SWITCH_INTERNALS_HTML);

  source->UseStringsJs();
}

}  // namespace

BrowserSwitchHandler::BrowserSwitchHandler() = default;

BrowserSwitchHandler::~BrowserSwitchHandler() = default;

void BrowserSwitchHandler::RegisterMessages() {
  web_ui()->RegisterMessageCallback(
      "launchAlternativeBrowserAndCloseTab",
      base::BindRepeating(
          &BrowserSwitchHandler::HandleLaunchAlternativeBrowserAndCloseTab,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "gotoNewTabPage",
      base::BindRepeating(&BrowserSwitchHandler::HandleGotoNewTabPage,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "getAllRulesets",
      base::BindRepeating(&BrowserSwitchHandler::HandleGetAllRulesets,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "getDecision",
      base::BindRepeating(&BrowserSwitchHandler::HandleGetDecision,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "getTimestamps",
      base::BindRepeating(&BrowserSwitchHandler::HandleGetTimestamps,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "getRulesetSources",
      base::BindRepeating(&BrowserSwitchHandler::HandleGetRulesetSources,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "refreshXml", base::BindRepeating(&BrowserSwitchHandler::HandleRefreshXml,
                                        base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "isBrowserSwitcherEnabled",
      base::BindRepeating(&BrowserSwitchHandler::HandleIsBrowserSwitchEnabled,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "getBrowserSwitchInternalsJson",
      base::BindRepeating(
          &BrowserSwitchHandler::HandleGetBrowserSwitchInternalsJson,
          base::Unretained(this)));
}

void BrowserSwitchHandler::OnJavascriptAllowed() {
  auto* service = GetBrowserSwitcherService(web_ui());
  prefs_subscription_ = service->prefs().RegisterPrefsChangedCallback(
      base::BindRepeating(&BrowserSwitchHandler::OnBrowserSwitcherPrefsChanged,
                          base::Unretained(this)));
  service_subscription_ =
      service->RegisterAllRulesetsParsedCallback(base::BindRepeating(
          &BrowserSwitchHandler::OnAllRulesetsParsed, base::Unretained(this)));
}

void BrowserSwitchHandler::OnJavascriptDisallowed() {
  prefs_subscription_ = {};
  service_subscription_ = {};
}

void BrowserSwitchHandler::OnAllRulesetsParsed(
    browser_switcher::BrowserSwitcherService* service) {
  SendDataChangedEvent();
}

void BrowserSwitchHandler::OnBrowserSwitcherPrefsChanged(
    browser_switcher::BrowserSwitcherPrefs* prefs,
    const std::vector<std::string>& changed_prefs) {
  SendDataChangedEvent();
}

void BrowserSwitchHandler::SendDataChangedEvent() {
  FireWebUIListener("data-changed");
}

void BrowserSwitchHandler::HandleLaunchAlternativeBrowserAndCloseTab(
    const base::Value::List& args) {
  AllowJavascript();

  std::string callback_id = args[0].GetString();
  std::string url_spec = args[1].GetString();
  GURL url(url_spec);

  auto* service = GetBrowserSwitcherService(web_ui());
  bool should_switch = service->sitelist()->ShouldSwitch(url);
  if (!url.is_valid() || !should_switch) {
    // This URL shouldn't open in an alternative browser. Abort launch, because
    // something weird is going on (e.g. race condition from a new sitelist
    // being loaded).
    RejectJavascriptCallback(args[0], base::Value());
    return;
  }

  service->driver()->TryLaunch(
      url, base::BindOnce(&BrowserSwitchHandler::OnLaunchFinished,
                          weak_ptr_factory_.GetWeakPtr(),
                          base::TimeTicks::Now(), std::move(callback_id)));
}

void BrowserSwitchHandler::OnLaunchFinished(base::TimeTicks start,
                                            std::string callback_id,
                                            bool success) {
  const base::TimeDelta runtime = base::TimeTicks::Now() - start;
  UMA_HISTOGRAM_TIMES("BrowserSwitcher.LaunchTime", runtime);
  UMA_HISTOGRAM_BOOLEAN("BrowserSwitcher.LaunchSuccess", success);

  if (!success) {
    RejectJavascriptCallback(base::Value(callback_id), base::Value());
    return;
  }

  auto* service = GetBrowserSwitcherService(web_ui());
  auto* profile = Profile::FromWebUI(web_ui());
  // We don't need to resolve the promise, because the tab will close (or
  // navigate to about:newtab) anyways.
  if (service->prefs().KeepLastTab() && IsLastTab(profile)) {
    GotoNewTabPage(web_ui()->GetWebContents());
  } else {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(&content::WebContents::ClosePage,
                                  web_ui()->GetWebContents()->GetWeakPtr()));
  }
}

void BrowserSwitchHandler::HandleGotoNewTabPage(const base::Value::List& args) {
  GotoNewTabPage(web_ui()->GetWebContents());
}

void BrowserSwitchHandler::HandleGetAllRulesets(const base::Value::List& args) {
  AllowJavascript();
  auto* service = GetBrowserSwitcherService(web_ui());
  auto retval =
      base::Value::Dict()
          .Set("gpo", RuleSetToDict(service->prefs().GetRules()))
          .Set("ieem", RuleSetToDict(*service->sitelist()->GetIeemSitelist()))
          .Set("external_sitelist",
               RuleSetToDict(*service->sitelist()->GetExternalSitelist()))
          .Set("external_greylist",
               RuleSetToDict(*service->sitelist()->GetExternalGreylist()));
  ResolveJavascriptCallback(args[0], retval);
}

void BrowserSwitchHandler::HandleGetDecision(const base::Value::List& args) {
  AllowJavascript();

  GURL url = GURL(args[1].GetString());
  if (!url.is_valid()) {
    RejectJavascriptCallback(args[0], base::Value());
    return;
  }

  auto* service = GetBrowserSwitcherService(web_ui());
  browser_switcher::Decision decision = service->sitelist()->GetDecision(url);

  std::string_view action_name =
      (decision.action == browser_switcher::kStay) ? "stay" : "go";

  std::string_view reason_name;
  switch (decision.reason) {
    case browser_switcher::kDisabled:
      reason_name = "globally_disabled";
      break;
    case browser_switcher::kProtocol:
      reason_name = "protocol";
      break;
    case browser_switcher::kSitelist:
      reason_name = "sitelist";
      break;
    case browser_switcher::kGreylist:
      reason_name = "greylist";
      break;
    case browser_switcher::kDefault:
      reason_name = "default";
      break;
  }

  // clang-format off
  auto retval =
      base::Value::Dict()
          .Set("action", action_name)
          .Set("reason", reason_name);
  // clang-format on

  if (decision.matching_rule) {
    retval.Set("matching_rule", decision.matching_rule->ToString());
  }

  ResolveJavascriptCallback(args[0], retval);
}

void BrowserSwitchHandler::HandleGetTimestamps(const base::Value::List& args) {
  AllowJavascript();

  auto* service = GetBrowserSwitcherService(web_ui());
  auto* downloader = service->sitelist_downloader();

  if (!downloader) {
    ResolveJavascriptCallback(args[0], base::Value());
    return;
  }

  auto retval =
      base::Value::Dict()
          .Set("last_fetch",
               downloader->last_refresh_time().InMillisecondsFSinceUnixEpoch())
          .Set("next_fetch",
               downloader->next_refresh_time().InMillisecondsFSinceUnixEpoch());

  ResolveJavascriptCallback(args[0], retval);
}

void BrowserSwitchHandler::HandleGetRulesetSources(
    const base::Value::List& args) {
  AllowJavascript();

  auto* service = GetBrowserSwitcherService(web_ui());
  std::vector<browser_switcher::RulesetSource> sources =
      service->GetRulesetSources();

  base::Value::Dict retval;
  for (const auto& source : sources) {
    base::Value val;
    if (source.url.is_valid()) {
      val = base::Value(source.url.spec());
    }
    // |pref_name| is something like "browser_switcher.blah"; however path
    // expansion is not expected on it as the JavaScript expects to see
    // "browser_switcher.blah" as a key in the object, not a nested hierarchy.
    retval.Set(source.pref_name, std::move(val));
  }
  ResolveJavascriptCallback(args[0], retval);
}

void BrowserSwitchHandler::HandleRefreshXml(const base::Value::List& args) {
  auto* service = GetBrowserSwitcherService(web_ui());
  service->StartDownload(base::TimeDelta());
}

void BrowserSwitchHandler::HandleIsBrowserSwitchEnabled(
    const base::Value::List& args) {
  AllowJavascript();

  auto* service = GetBrowserSwitcherService(web_ui());
  ResolveJavascriptCallback(args[0], base::Value(service->prefs().IsEnabled()));
}

void BrowserSwitchHandler::HandleGetBrowserSwitchInternalsJson(
    const base::Value::List& args) {
  AllowJavascript();
  CHECK_EQ(1U, args.size());
  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(callback_id,
                            base::Value(GetBrowserSwitchInternalsJson()));
}

std::string BrowserSwitchHandler::GetBrowserSwitchInternalsJson() {
  auto* service = GetBrowserSwitcherService(web_ui());
  auto& service_prefs = service->prefs();
  base::Value::Dict dict;

  // Policies
  base::Value::Dict policies;

  policies.Set(policy::key::kBrowserSwitcherEnabled,
               base::Value(service_prefs.IsEnabled()));
  policies.Set(policy::key::kAlternativeBrowserPath,
               base::Value(service_prefs.GetAlternativeBrowserPath()));
  policies.Set(policy::key::kAlternativeBrowserParameters,
               base::Value(base::ToValueList(
                   service_prefs.GetAlternativeBrowserParameters())));
  policies.Set(policy::key::kBrowserSwitcherKeepLastChromeTab,
               base::Value(service_prefs.KeepLastTab()));
  policies.Set(policy::key::kBrowserSwitcherDelay,
               base::Value(service_prefs.GetDelay()));
  policies.Set(policy::key::kBrowserSwitcherExternalSitelistUrl,
               base::Value(service_prefs.GetExternalSitelistUrl().spec()));
  policies.Set(policy::key::kBrowserSwitcherExternalGreylistUrl,
               base::Value(service_prefs.GetExternalGreylistUrl().spec()));
  policies.Set(policy::key::kBrowserSwitcherParsingMode,
               base::Value(static_cast<int>(service_prefs.GetParsingMode())));

#if BUILDFLAG(IS_WIN)
  policies.Set(policy::key::kBrowserSwitcherUseIeSitelist,
               base::Value(service_prefs.UseIeSitelist()));
  policies.Set(policy::key::kBrowserSwitcherChromePath,
               base::Value(service_prefs.GetChromePath().LossyDisplayName()));
  policies.Set(
      policy::key::kBrowserSwitcherChromeParameters,
      base::Value(base::ToValueList(service_prefs.GetChromeParameters())));
#endif

  dict.Set("policies", std::move(policies));

  // Alternative Browser
  dict.Set("alternativeBrowserName", service->driver()->GetBrowserName());
  dict.Set("alternativeBrowserPath", service_prefs.GetAlternativeBrowserPath());

  // Rulesets
  base::Value::Dict rulesets;
  rulesets.Set("gpo", RuleSetToDict(service->prefs().GetRules()));
  rulesets.Set("ieem", RuleSetToDict(*service->sitelist()->GetIeemSitelist()));
  rulesets.Set("external_sitelist",
               RuleSetToDict(*service->sitelist()->GetExternalSitelist()));
  rulesets.Set("external_greylist",
               RuleSetToDict(*service->sitelist()->GetExternalGreylist()));
  dict.Set("rulesets", std::move(rulesets));

  // Ruleset Sources
  std::vector<browser_switcher::RulesetSource> sources =
      service->GetRulesetSources();
  base::Value::Dict rulesetSources;
  for (const auto& source : sources) {
    rulesetSources.Set(source.pref_name, source.url.is_valid()
                                             ? base::Value(source.url.spec())
                                             : base::Value());
  }
  dict.Set("rulesetSources", std::move(rulesetSources));

  // XML Timestamps
  auto* downloader = service->sitelist_downloader();
  if (downloader) {
    base::Value::Dict timestamps;
    timestamps.Set("lastFetch",
                   base::TimeFormatHTTP(downloader->last_refresh_time()));
    timestamps.Set("nextFetch",
                   base::TimeFormatHTTP(downloader->next_refresh_time()));
    dict.Set("xmlTimestamps", std::move(timestamps));
  }

  std::string json;
  base::JSONWriter::WriteWithOptions(
      dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
  return json;
}

bool BrowserSwitchUIConfig::IsWebUIEnabled(
    content::BrowserContext* browser_context) {
  return browser_context && !browser_context->IsOffTheRecord();
}

BrowserSwitchUI::BrowserSwitchUI(content::WebUI* web_ui)
    : WebUIController(web_ui) {
  web_ui->AddMessageHandler(std::make_unique<BrowserSwitchHandler>());

  // Set up the chrome://browser-switch source.
  CreateAndAddBrowserSwitchUIHTMLSource(web_ui);
}