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

#include "components/permissions/permission_context_base.h"

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

#include "base/bind.h"
#include "base/feature_list.h"
#include "base/metrics/field_trial.h"
#include "base/metrics/field_trial_params.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "components/content_settings/core/browser/host_content_settings_map.h"
#include "components/content_settings/core/common/content_settings.h"
#include "components/content_settings/core/common/content_settings_types.h"
#include "components/permissions/features.h"
#include "components/permissions/permission_decision_auto_blocker.h"
#include "components/permissions/permission_request_id.h"
#include "components/permissions/permission_request_manager.h"
#include "components/permissions/permission_uma_util.h"
#include "components/permissions/permission_util.h"
#include "components/permissions/test/mock_permission_prompt_factory.h"
#include "components/permissions/test/test_permissions_client.h"
#include "components/ukm/content/source_url_recorder.h"
#include "components/ukm/test_ukm_recorder.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h"
#include "content/public/test/mock_render_process_host.h"
#include "content/public/test/test_renderer_host.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/url_util.h"

namespace permissions {

const char* const kPermissionsKillSwitchFieldStudy =
    PermissionContextBase::kPermissionsKillSwitchFieldStudy;
const char* const kPermissionsKillSwitchBlockedValue =
    PermissionContextBase::kPermissionsKillSwitchBlockedValue;
const char kPermissionsKillSwitchTestGroup[] = "TestGroup";

class TestPermissionContext : public PermissionContextBase {
 public:
  TestPermissionContext(content::BrowserContext* browser_context,
                        const ContentSettingsType content_settings_type)
      : PermissionContextBase(
            browser_context,
            content_settings_type,
            blink::mojom::PermissionsPolicyFeature::kNotFound),
        tab_context_updated_(false) {}

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

  ~TestPermissionContext() override {}

  const std::vector<ContentSetting>& decisions() const { return decisions_; }

  bool tab_context_updated() const { return tab_context_updated_; }

  // Once a decision for the requested permission has been made, run the
  // callback.
  void TrackPermissionDecision(ContentSetting content_setting) {
    decisions_.push_back(content_setting);
    // Null check required here as the quit_closure_ can also be run and reset
    // first from within DecidePermission.
    if (quit_closure_) {
      std::move(quit_closure_).Run();
    }
  }

  ContentSetting GetContentSettingFromMap(const GURL& url_a,
                                          const GURL& url_b) {
    auto* map = PermissionsClient::Get()->GetSettingsMap(browser_context());
    return map->GetContentSetting(url_a.DeprecatedGetOriginAsURL(),
                                  url_b.DeprecatedGetOriginAsURL(),
                                  content_settings_type());
  }

  void RequestPermission(content::WebContents* web_contents,
                         const PermissionRequestID& id,
                         const GURL& requesting_frame,
                         bool user_gesture,
                         BrowserPermissionCallback callback) override {
    base::RunLoop run_loop;
    quit_closure_ = run_loop.QuitClosure();
    PermissionContextBase::RequestPermission(web_contents, id, requesting_frame,
                                             true /* user_gesture */,
                                             std::move(callback));
    run_loop.Run();
  }

  void DecidePermission(content::WebContents* web_contents,
                        const PermissionRequestID& id,
                        const GURL& requesting_origin,
                        const GURL& embedding_origin,
                        bool user_gesture,
                        BrowserPermissionCallback callback) override {
    PermissionContextBase::DecidePermission(web_contents, id, requesting_origin,
                                            embedding_origin, user_gesture,
                                            std::move(callback));
    if (respond_permission_) {
      std::move(respond_permission_).Run();
    } else {
      // Stop the run loop from spinning indefinitely if no response callback
      // has been set, as is the case with TestParallelRequests.
      std::move(quit_closure_).Run();
    }
  }

  // Set the callback to run if the permission is being responded to in the
  // test. This is left empty where no response is needed, such as in parallel
  // requests, invalid origin, and killswitch.
  void SetRespondPermissionCallback(base::OnceClosure callback) {
    respond_permission_ = std::move(callback);
  }

 protected:
  void UpdateTabContext(const PermissionRequestID& id,
                        const GURL& requesting_origin,
                        bool allowed) override {
    tab_context_updated_ = true;
  }

  bool IsRestrictedToSecureOrigins() const override { return false; }

 private:
  std::vector<ContentSetting> decisions_;
  bool tab_context_updated_;
  base::OnceClosure quit_closure_;
  // Callback for responding to a permission once the request has been completed
  // (valid URL, kill switch disabled)
  base::OnceClosure respond_permission_;
};

class TestKillSwitchPermissionContext : public TestPermissionContext {
 public:
  TestKillSwitchPermissionContext(
      content::BrowserContext* browser_context,
      const ContentSettingsType content_settings_type)
      : TestPermissionContext(browser_context, content_settings_type) {
    ResetFieldTrialList();
  }

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

  void ResetFieldTrialList() {
    scoped_feature_list_.Reset();
    scoped_feature_list_.Init();
  }

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

class TestSecureOriginRestrictedPermissionContext
    : public TestPermissionContext {
 public:
  TestSecureOriginRestrictedPermissionContext(
      content::BrowserContext* browser_context,
      const ContentSettingsType content_settings_type)
      : TestPermissionContext(browser_context, content_settings_type) {}

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

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

class TestPermissionsClientBypassExtensionOriginCheck
    : public TestPermissionsClient {
 public:
  bool CanBypassEmbeddingOriginCheck(const GURL& requesting_origin,
                                     const GURL& embedding_origin) override {
    return requesting_origin.SchemeIs("chrome-extension");
  }
};

class PermissionContextBaseTests : public content::RenderViewHostTestHarness {
 public:
  PermissionContextBaseTests(const PermissionContextBaseTests&) = delete;
  PermissionContextBaseTests& operator=(const PermissionContextBaseTests&) =
      delete;

 protected:
  PermissionContextBaseTests() {}
  ~PermissionContextBaseTests() override {}

  // Accept or dismiss the permission prompt.
  void RespondToPermission(TestPermissionContext* context,
                           const PermissionRequestID& id,
                           const GURL& url,
                           ContentSetting response) {
    DCHECK(response == CONTENT_SETTING_ALLOW ||
           response == CONTENT_SETTING_BLOCK ||
           response == CONTENT_SETTING_ASK);
    using AutoResponseType = PermissionRequestManager::AutoResponseType;
    AutoResponseType decision = AutoResponseType::DISMISS;
    if (response == CONTENT_SETTING_ALLOW)
      decision = AutoResponseType::ACCEPT_ALL;
    else if (response == CONTENT_SETTING_BLOCK)
      decision = AutoResponseType::DENY_ALL;
    prompt_factory_->set_response_type(decision);
  }

  void TestAskAndDecide_TestContent(ContentSettingsType content_settings_type,
                                    ContentSetting decision) {
    ukm::InitializeSourceUrlRecorderForWebContents(web_contents());
    ukm::TestAutoSetUkmRecorder ukm_recorder;
    TestPermissionContext permission_context(browser_context(),
                                             content_settings_type);
    GURL url("https://www.google.com");
    SetUpUrl(url);
    base::HistogramTester histograms;

    const PermissionRequestID id(
        web_contents()->GetMainFrame()->GetProcess()->GetID(),
        web_contents()->GetMainFrame()->GetRoutingID(),
        PermissionRequestID::RequestLocalId());
    permission_context.SetRespondPermissionCallback(base::BindOnce(
        &PermissionContextBaseTests::RespondToPermission,
        base::Unretained(this), &permission_context, id, url, decision));
    permission_context.RequestPermission(
        web_contents(), id, url, true /* user_gesture */,
        base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                       base::Unretained(&permission_context)));
    ASSERT_EQ(1u, permission_context.decisions().size());
    EXPECT_EQ(decision, permission_context.decisions()[0]);
    EXPECT_TRUE(permission_context.tab_context_updated());

    std::string decision_string;
    absl::optional<PermissionAction> action;
    if (decision == CONTENT_SETTING_ALLOW) {
      decision_string = "Accepted";
      action = PermissionAction::GRANTED;
    } else if (decision == CONTENT_SETTING_BLOCK) {
      decision_string = "Denied";
      action = PermissionAction::DENIED;
    } else if (decision == CONTENT_SETTING_ASK) {
      decision_string = "Dismissed";
      action = PermissionAction::DISMISSED;
    }

    if (!decision_string.empty()) {
      histograms.ExpectUniqueSample(
          "Permissions.Prompt." + decision_string + ".PriorDismissCount2." +
              PermissionUtil::GetPermissionString(content_settings_type),
          0, 1);
      histograms.ExpectUniqueSample(
          "Permissions.Prompt." + decision_string + ".PriorIgnoreCount2." +
              PermissionUtil::GetPermissionString(content_settings_type),
          0, 1);
#if BUILDFLAG(IS_ANDROID)
      histograms.ExpectUniqueSample(
          "Permissions.Action.WithDisposition.ModalDialog",
          static_cast<int>(action.value()), 1);
#else
      histograms.ExpectUniqueSample(
          "Permissions.Action.WithDisposition.AnchoredBubble",
          static_cast<int>(action.value()), 1);
#endif
    }

    EXPECT_EQ(decision, permission_context.GetContentSettingFromMap(url, url));

    histograms.ExpectUniqueSample(
        "Permissions.AutoBlocker.EmbargoPromptSuppression",
        static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), 1);
    histograms.ExpectUniqueSample(
        "Permissions.AutoBlocker.EmbargoStatus",
        static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), 1);

    if (action.has_value()) {
      auto entries = ukm_recorder.GetEntriesByName("Permission");
      EXPECT_EQ(1u, entries.size());
      auto* entry = entries.front();
      ukm_recorder.ExpectEntrySourceHasUrl(entry, url);

      size_t num_values = 0;

      EXPECT_NE(ContentSettingTypeToHistogramValue(content_settings_type,
                                                   &num_values),
                -1);

      EXPECT_EQ(*ukm_recorder.GetEntryMetric(entry, "Source"),
                static_cast<int64_t>(PermissionSourceUI::PROMPT));
      EXPECT_EQ(*ukm_recorder.GetEntryMetric(entry, "PermissionType"),
                static_cast<int64_t>(ContentSettingTypeToHistogramValue(
                    content_settings_type, &num_values)));
      EXPECT_EQ(*ukm_recorder.GetEntryMetric(entry, "Action"),
                static_cast<int64_t>(action.value()));

#if BUILDFLAG(IS_ANDROID)
      EXPECT_EQ(
          *ukm_recorder.GetEntryMetric(entry, "PromptDisposition"),
          static_cast<int64_t>(PermissionPromptDisposition::MODAL_DIALOG));
#else
      EXPECT_EQ(
          *ukm_recorder.GetEntryMetric(entry, "PromptDisposition"),
          static_cast<int64_t>(PermissionPromptDisposition::ANCHORED_BUBBLE));
#endif
    }
  }

  void DismissMultipleTimesAndExpectBlock(
      const GURL& url,
      ContentSettingsType content_settings_type,
      uint32_t iterations) {
    base::HistogramTester histograms;

    // Dismiss |iterations| times. The final dismiss should change the decision
    // from dismiss to block, and hence change the persisted content setting.
    for (uint32_t i = 0; i < iterations; ++i) {
      TestPermissionContext permission_context(browser_context(),
                                               content_settings_type);
      const PermissionRequestID id(
          web_contents()->GetMainFrame()->GetProcess()->GetID(),
          web_contents()->GetMainFrame()->GetRoutingID(),
          PermissionRequestID::RequestLocalId());

      permission_context.SetRespondPermissionCallback(
          base::BindOnce(&PermissionContextBaseTests::RespondToPermission,
                         base::Unretained(this), &permission_context, id, url,
                         CONTENT_SETTING_ASK));

      permission_context.RequestPermission(
          web_contents(), id, url, true /* user_gesture */,
          base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                         base::Unretained(&permission_context)));
      histograms.ExpectTotalCount(
          "Permissions.Prompt.Dismissed.PriorDismissCount2." +
              PermissionUtil::GetPermissionString(content_settings_type),
          i + 1);
      histograms.ExpectBucketCount(
          "Permissions.Prompt.Dismissed.PriorDismissCount2." +
              PermissionUtil::GetPermissionString(content_settings_type),
          i, 1);

      histograms.ExpectTotalCount("Permissions.AutoBlocker.EmbargoStatus",
                                  i + 1);

      PermissionResult result = permission_context.GetPermissionStatus(
          nullptr /* render_frame_host */, url, url);

      histograms.ExpectUniqueSample(
          "Permissions.AutoBlocker.EmbargoPromptSuppression",
          static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), i + 1);
      if (i < 2) {
        EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
        EXPECT_EQ(CONTENT_SETTING_ASK, result.content_setting);
        histograms.ExpectUniqueSample(
            "Permissions.AutoBlocker.EmbargoStatus",
            static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), i + 1);
      } else {
        EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
        EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
        histograms.ExpectBucketCount(
            "Permissions.AutoBlocker.EmbargoStatus",
            static_cast<int>(PermissionEmbargoStatus::REPEATED_DISMISSALS), 1);
      }

      ASSERT_EQ(1u, permission_context.decisions().size());
      EXPECT_EQ(CONTENT_SETTING_ASK, permission_context.decisions()[0]);
      EXPECT_TRUE(permission_context.tab_context_updated());
    }

    TestPermissionContext permission_context(browser_context(),
                                             content_settings_type);
    const PermissionRequestID id(
        web_contents()->GetMainFrame()->GetProcess()->GetID(),
        web_contents()->GetMainFrame()->GetRoutingID(),
        PermissionRequestID::RequestLocalId());

    permission_context.SetRespondPermissionCallback(
        base::BindOnce(&PermissionContextBaseTests::RespondToPermission,
                       base::Unretained(this), &permission_context, id, url,
                       CONTENT_SETTING_ASK));

    permission_context.RequestPermission(
        web_contents(), id, url, true /* user_gesture */,
        base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                       base::Unretained(&permission_context)));

    PermissionResult result = permission_context.GetPermissionStatus(
        nullptr /* render_frame_host */, url, url);
    EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
    EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
    histograms.ExpectBucketCount(
        "Permissions.AutoBlocker.EmbargoPromptSuppression",
        static_cast<int>(PermissionEmbargoStatus::REPEATED_DISMISSALS), 1);
  }

  void TestBlockOnSeveralDismissals_TestContent() {
    GURL url("https://www.google.com");
    SetUpUrl(url);
    base::HistogramTester histograms;

    {
      // Ensure that > 3 dismissals behaves correctly when the
      // BlockPromptsIfDismissedOften feature is off.
      base::test::ScopedFeatureList feature_list;
      feature_list.InitAndDisableFeature(
          features::kBlockPromptsIfDismissedOften);

      for (uint32_t i = 0; i < 4; ++i) {
        TestPermissionContext permission_context(
            browser_context(), ContentSettingsType::GEOLOCATION);

        const PermissionRequestID id(
            web_contents()->GetMainFrame()->GetProcess()->GetID(),
            web_contents()->GetMainFrame()->GetRoutingID(),
            PermissionRequestID::RequestLocalId(i + 1));

        permission_context.SetRespondPermissionCallback(
            base::BindOnce(&PermissionContextBaseTests::RespondToPermission,
                           base::Unretained(this), &permission_context, id, url,
                           CONTENT_SETTING_ASK));
        permission_context.RequestPermission(
            web_contents(), id, url, true /* user_gesture */,
            base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                           base::Unretained(&permission_context)));
        histograms.ExpectTotalCount(
            "Permissions.Prompt.Dismissed.PriorDismissCount2.Geolocation",
            i + 1);
        histograms.ExpectBucketCount(
            "Permissions.Prompt.Dismissed.PriorDismissCount2.Geolocation", i,
            1);
        histograms.ExpectUniqueSample(
            "Permissions.AutoBlocker.EmbargoPromptSuppression",
            static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), i + 1);
        histograms.ExpectUniqueSample(
            "Permissions.AutoBlocker.EmbargoStatus",
            static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), i + 1);

        ASSERT_EQ(1u, permission_context.decisions().size());
        EXPECT_EQ(CONTENT_SETTING_ASK, permission_context.decisions()[0]);
        EXPECT_TRUE(permission_context.tab_context_updated());
        EXPECT_EQ(CONTENT_SETTING_ASK,
                  permission_context.GetContentSettingFromMap(url, url));
      }

      // Flush the dismissal counts.
      auto* map = PermissionsClient::Get()->GetSettingsMap(browser_context());
      map->ClearSettingsForOneType(
          ContentSettingsType::PERMISSION_AUTOBLOCKER_DATA);
    }

    EXPECT_TRUE(
        base::FeatureList::IsEnabled(features::kBlockPromptsIfDismissedOften));

    // Sanity check independence per permission type by checking two of them.
    DismissMultipleTimesAndExpectBlock(url, ContentSettingsType::GEOLOCATION,
                                       3);
    DismissMultipleTimesAndExpectBlock(url, ContentSettingsType::NOTIFICATIONS,
                                       3);
  }

  void TestVariationBlockOnSeveralDismissals_TestContent() {
    GURL url("https://www.google.com");
    SetUpUrl(url);
    base::HistogramTester histograms;

    std::map<std::string, std::string> params;
    params
        [PermissionDecisionAutoBlocker::GetPromptDismissCountKeyForTesting()] =
            "5";
    base::test::ScopedFeatureList scoped_feature_list;
    scoped_feature_list.InitAndEnableFeatureWithParameters(
        features::kBlockPromptsIfDismissedOften, params);

    std::map<std::string, std::string> actual_params;
    EXPECT_TRUE(base::GetFieldTrialParamsByFeature(
        features::kBlockPromptsIfDismissedOften, &actual_params));
    EXPECT_EQ(params, actual_params);

    EXPECT_TRUE(base::GetFieldTrialParamsByFeature(
        features::kBlockPromptsIfDismissedOften, &actual_params));
    EXPECT_EQ(params, actual_params);

    for (uint32_t i = 0; i < 5; ++i) {
      TestPermissionContext permission_context(browser_context(),
                                               ContentSettingsType::MIDI_SYSEX);

      const PermissionRequestID id(
          web_contents()->GetMainFrame()->GetProcess()->GetID(),
          web_contents()->GetMainFrame()->GetRoutingID(),
          PermissionRequestID::RequestLocalId(i + 1));
      permission_context.SetRespondPermissionCallback(
          base::BindOnce(&PermissionContextBaseTests::RespondToPermission,
                         base::Unretained(this), &permission_context, id, url,
                         CONTENT_SETTING_ASK));
      permission_context.RequestPermission(
          web_contents(), id, url, true /* user_gesture */,
          base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                         base::Unretained(&permission_context)));

      EXPECT_EQ(1u, permission_context.decisions().size());
      ASSERT_EQ(CONTENT_SETTING_ASK, permission_context.decisions()[0]);
      EXPECT_TRUE(permission_context.tab_context_updated());
      PermissionResult result = permission_context.GetPermissionStatus(
          nullptr /* render_frame_host */, url, url);

      histograms.ExpectTotalCount(
          "Permissions.Prompt.Dismissed.PriorDismissCount2.MidiSysEx", i + 1);
      histograms.ExpectBucketCount(
          "Permissions.Prompt.Dismissed.PriorDismissCount2.MidiSysEx", i, 1);
      histograms.ExpectUniqueSample(
          "Permissions.AutoBlocker.EmbargoPromptSuppression",
          static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), i + 1);
      histograms.ExpectTotalCount("Permissions.AutoBlocker.EmbargoStatus",
                                  i + 1);
      if (i < 4) {
        EXPECT_EQ(CONTENT_SETTING_ASK, result.content_setting);
        EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
        histograms.ExpectUniqueSample(
            "Permissions.AutoBlocker.EmbargoStatus",
            static_cast<int>(PermissionEmbargoStatus::NOT_EMBARGOED), i + 1);
      } else {
        EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
        EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
        histograms.ExpectBucketCount(
            "Permissions.AutoBlocker.EmbargoStatus",
            static_cast<int>(PermissionEmbargoStatus::REPEATED_DISMISSALS), 1);
      }
    }

    // Ensure that we finish in the block state.
    TestPermissionContext permission_context(browser_context(),
                                             ContentSettingsType::MIDI_SYSEX);
    PermissionResult result = permission_context.GetPermissionStatus(
        nullptr /* render_frame_host */, url, url);
    EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
    EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
  }

  void TestRequestPermissionInvalidUrl(
      ContentSettingsType content_settings_type) {
    base::HistogramTester histograms;
    TestPermissionContext permission_context(browser_context(),
                                             content_settings_type);
    GURL url;
    ASSERT_FALSE(url.is_valid());
    controller().LoadURL(url, content::Referrer(), ui::PAGE_TRANSITION_TYPED,
                         std::string());

    const PermissionRequestID id(
        web_contents()->GetMainFrame()->GetProcess()->GetID(),
        web_contents()->GetMainFrame()->GetRoutingID(),
        PermissionRequestID::RequestLocalId());
    permission_context.RequestPermission(
        web_contents(), id, url, true /* user_gesture */,
        base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                       base::Unretained(&permission_context)));

    ASSERT_EQ(1u, permission_context.decisions().size());
    EXPECT_EQ(CONTENT_SETTING_BLOCK, permission_context.decisions()[0]);
    EXPECT_TRUE(permission_context.tab_context_updated());
    EXPECT_EQ(CONTENT_SETTING_ASK,
              permission_context.GetContentSettingFromMap(url, url));
    histograms.ExpectTotalCount(
        "Permissions.AutoBlocker.EmbargoPromptSuppression", 0);
  }

  void TestGrantAndRevoke_TestContent(ContentSettingsType content_settings_type,
                                      ContentSetting expected_default) {
    TestPermissionContext permission_context(browser_context(),
                                             content_settings_type);
    GURL url("https://www.google.com");
    SetUpUrl(url);

    const PermissionRequestID id(
        web_contents()->GetMainFrame()->GetProcess()->GetID(),
        web_contents()->GetMainFrame()->GetRoutingID(),
        PermissionRequestID::RequestLocalId());
    permission_context.SetRespondPermissionCallback(
        base::BindOnce(&PermissionContextBaseTests::RespondToPermission,
                       base::Unretained(this), &permission_context, id, url,
                       CONTENT_SETTING_ALLOW));

    permission_context.RequestPermission(
        web_contents(), id, url, true /* user_gesture */,
        base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                       base::Unretained(&permission_context)));

    ASSERT_EQ(1u, permission_context.decisions().size());
    EXPECT_EQ(CONTENT_SETTING_ALLOW, permission_context.decisions()[0]);
    EXPECT_TRUE(permission_context.tab_context_updated());
    EXPECT_EQ(CONTENT_SETTING_ALLOW,
              permission_context.GetContentSettingFromMap(url, url));

    // Try to reset permission.
    permission_context.ResetPermission(url.DeprecatedGetOriginAsURL(),
                                       url.DeprecatedGetOriginAsURL());
    ContentSetting setting_after_reset =
        permission_context.GetContentSettingFromMap(url, url);
    ContentSetting default_setting =
        PermissionsClient::Get()
            ->GetSettingsMap(browser_context())
            ->GetDefaultContentSetting(content_settings_type, nullptr);
    EXPECT_EQ(default_setting, setting_after_reset);
  }

  void TestGlobalPermissionsKillSwitch(
      ContentSettingsType content_settings_type) {
    TestKillSwitchPermissionContext permission_context(browser_context(),
                                                       content_settings_type);
    permission_context.ResetFieldTrialList();

    EXPECT_FALSE(permission_context.IsPermissionKillSwitchOn());
    std::map<std::string, std::string> params;
    params[PermissionUtil::GetPermissionString(content_settings_type)] =
        kPermissionsKillSwitchBlockedValue;
    base::AssociateFieldTrialParams(kPermissionsKillSwitchFieldStudy,
                                    kPermissionsKillSwitchTestGroup, params);
    base::FieldTrialList::CreateFieldTrial(kPermissionsKillSwitchFieldStudy,
                                           kPermissionsKillSwitchTestGroup);
    EXPECT_TRUE(permission_context.IsPermissionKillSwitchOn());
  }

  void TestSecureOriginRestrictedPermissionContextCheck(
      const std::string& requesting_url_spec,
      const std::string& embedding_url_spec,
      bool expect_allowed) {
    GURL requesting_origin(requesting_url_spec);
    GURL embedding_origin(embedding_url_spec);
    TestSecureOriginRestrictedPermissionContext permission_context(
        browser_context(), ContentSettingsType::GEOLOCATION);
    bool result = permission_context.IsPermissionAvailableToOrigins(
        requesting_origin, embedding_origin);
    EXPECT_EQ(expect_allowed, result)
        << "test case (requesting, embedding): (" << requesting_url_spec << ", "
        << embedding_url_spec << ") with secure-origin requirement"
        << " on";

    // With no secure-origin limitation, this check should always return pass.
    TestPermissionContext new_context(browser_context(),
                                      ContentSettingsType::GEOLOCATION);
    result = new_context.IsPermissionAvailableToOrigins(requesting_origin,
                                                        embedding_origin);
    EXPECT_EQ(true, result)
        << "test case (requesting, embedding): (" << requesting_url_spec << ", "
        << embedding_url_spec << ") with secure-origin requirement"
        << " off";
  }

  // Don't call this more than once in the same test, as it persists data to
  // HostContentSettingsMap.
  void TestParallelRequests(ContentSetting response) {
    TestPermissionContext permission_context(browser_context(),
                                             ContentSettingsType::GEOLOCATION);
    GURL url("http://www.google.com");
    SetUpUrl(url);

    const PermissionRequestID id1(
        web_contents()->GetMainFrame()->GetProcess()->GetID(),
        web_contents()->GetMainFrame()->GetRoutingID(),
        PermissionRequestID::RequestLocalId(1));
    const PermissionRequestID id2(
        web_contents()->GetMainFrame()->GetProcess()->GetID(),
        web_contents()->GetMainFrame()->GetRoutingID(),
        PermissionRequestID::RequestLocalId(2));

    // Request a permission without setting the callback to DecidePermission.
    permission_context.RequestPermission(
        web_contents(), id1, url, true /* user_gesture */,
        base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                       base::Unretained(&permission_context)));

    EXPECT_EQ(0u, permission_context.decisions().size());

    // Set the callback, and make a second permission request.
    permission_context.SetRespondPermissionCallback(base::BindOnce(
        &PermissionContextBaseTests::RespondToPermission,
        base::Unretained(this), &permission_context, id1, url, response));
    permission_context.RequestPermission(
        web_contents(), id2, url, true /* user_gesture */,
        base::BindOnce(&TestPermissionContext::TrackPermissionDecision,
                       base::Unretained(&permission_context)));

    ASSERT_EQ(2u, permission_context.decisions().size());
    EXPECT_EQ(response, permission_context.decisions()[0]);
    EXPECT_EQ(response, permission_context.decisions()[1]);
    EXPECT_TRUE(permission_context.tab_context_updated());

    EXPECT_EQ(response, permission_context.GetContentSettingFromMap(url, url));
  }

  void TestVirtualURL(const GURL& loaded_url,
                      const GURL& virtual_url,
                      const ContentSetting want_response,
                      const PermissionStatusSource& want_source) {
    TestPermissionContext permission_context(browser_context(),
                                             ContentSettingsType::GEOLOCATION);

    NavigateAndCommit(loaded_url);
    web_contents()->GetController().GetVisibleEntry()->SetVirtualURL(
        virtual_url);

    PermissionResult result = permission_context.GetPermissionStatus(
        web_contents()->GetMainFrame(), virtual_url, virtual_url);
    EXPECT_EQ(result.content_setting, want_response);
    EXPECT_EQ(result.source, want_source);
  }

  void SetUpUrl(const GURL& url) {
    NavigateAndCommit(url);
    prompt_factory_->DocumentOnLoadCompletedInPrimaryMainFrame();
  }

 private:
  // content::RenderViewHostTestHarness:
  void SetUp() override {
    content::RenderViewHostTestHarness::SetUp();
    PermissionRequestManager::CreateForWebContents(web_contents());
    PermissionRequestManager* manager =
        PermissionRequestManager::FromWebContents(web_contents());
    manager->set_enabled_app_level_notification_permission_for_testing(true);
    prompt_factory_ = std::make_unique<MockPermissionPromptFactory>(manager);
  }

  void TearDown() override {
    prompt_factory_.reset();
    content::RenderViewHostTestHarness::TearDown();
  }

  std::unique_ptr<MockPermissionPromptFactory> prompt_factory_;
  TestPermissionsClientBypassExtensionOriginCheck client_;
};

// Simulates clicking Accept. The permission should be granted and
// saved for future use.
TEST_F(PermissionContextBaseTests, TestAskAndGrant) {
  TestAskAndDecide_TestContent(ContentSettingsType::NOTIFICATIONS,
                               CONTENT_SETTING_ALLOW);
}

// Simulates clicking Block. The permission should be denied and
// saved for future use.
TEST_F(PermissionContextBaseTests, TestAskAndBlock) {
  TestAskAndDecide_TestContent(ContentSettingsType::GEOLOCATION,
                               CONTENT_SETTING_BLOCK);
}

// Simulates clicking Dismiss (X) in the prompt.
// The permission should be denied but not saved for future use.
TEST_F(PermissionContextBaseTests, TestAskAndDismiss) {
  TestAskAndDecide_TestContent(ContentSettingsType::MIDI_SYSEX,
                               CONTENT_SETTING_ASK);
}

// Simulates clicking Dismiss (X) in the prompt with the block on too
// many dismissals feature active. The permission should be blocked after
// several dismissals.
TEST_F(PermissionContextBaseTests, TestDismissUntilBlocked) {
  TestBlockOnSeveralDismissals_TestContent();
}

// Test setting a custom number of dismissals before block via variations.
TEST_F(PermissionContextBaseTests, TestDismissVariations) {
  TestVariationBlockOnSeveralDismissals_TestContent();
}

// Simulates non-valid requesting URL.
// The permission should be denied but not saved for future use.
TEST_F(PermissionContextBaseTests, TestNonValidRequestingUrl) {
  TestRequestPermissionInvalidUrl(ContentSettingsType::GEOLOCATION);
  TestRequestPermissionInvalidUrl(ContentSettingsType::NOTIFICATIONS);
  TestRequestPermissionInvalidUrl(ContentSettingsType::MIDI_SYSEX);
}

// Simulates granting and revoking of permissions.
TEST_F(PermissionContextBaseTests, TestGrantAndRevoke) {
  TestGrantAndRevoke_TestContent(ContentSettingsType::GEOLOCATION,
                                 CONTENT_SETTING_ASK);
  TestGrantAndRevoke_TestContent(ContentSettingsType::MIDI_SYSEX,
                                 CONTENT_SETTING_ASK);
#if BUILDFLAG(IS_ANDROID)
  TestGrantAndRevoke_TestContent(
      ContentSettingsType::PROTECTED_MEDIA_IDENTIFIER, CONTENT_SETTING_ASK);
  // TODO(timvolodine): currently no test for
  // ContentSettingsType::NOTIFICATIONS because notification permissions work
  // differently with infobars as compared to bubbles (crbug.com/453784).
#else
  TestGrantAndRevoke_TestContent(ContentSettingsType::NOTIFICATIONS,
                                 CONTENT_SETTING_ASK);
#endif
}

// Tests the global kill switch by enabling/disabling the Field Trials.
TEST_F(PermissionContextBaseTests, TestGlobalKillSwitch) {
  TestGlobalPermissionsKillSwitch(ContentSettingsType::GEOLOCATION);
  TestGlobalPermissionsKillSwitch(ContentSettingsType::NOTIFICATIONS);
  TestGlobalPermissionsKillSwitch(ContentSettingsType::MIDI_SYSEX);
  TestGlobalPermissionsKillSwitch(ContentSettingsType::DURABLE_STORAGE);
#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS_ASH)
  TestGlobalPermissionsKillSwitch(
      ContentSettingsType::PROTECTED_MEDIA_IDENTIFIER);
#endif
  TestGlobalPermissionsKillSwitch(ContentSettingsType::MEDIASTREAM_MIC);
  TestGlobalPermissionsKillSwitch(ContentSettingsType::MEDIASTREAM_CAMERA);
}

// Tests that secure origins are examined if switch is on, or ignored if off.
TEST_F(PermissionContextBaseTests,
       TestSecureOriginRestrictedPermissionContextSwitch) {
  url::ScopedSchemeRegistryForTests scoped_registry;
  url::AddSecureScheme("chrome-extension");
  struct {
    std::string requesting_url_spec;
    std::string embedding_url_spec;
    bool expect_permission_allowed;
  } kTestCases[] = {
      // Secure-origins that should be allowed.
      {"https://google.com", "https://foo.com",
       /*expect_allowed=*/true},
      {"https://www.bar.com", "https://foo.com",
       /*expect_allowed=*/true},
      {"https://localhost", "http://localhost",
       /*expect_allowed=*/true},

      {"http://localhost", "https://google.com",
       /*expect_allowed=*/true},
      {"https://google.com", "http://localhost",
       /*expect_allowed=*/true},
      {"https://foo.com", "file://some-file",
       /*expect_allowed=*/true},
      {"file://some-file", "https://foo.com",
       /*expect_allowed=*/true},
      {"https://foo.com", "about:blank",
       /*expect_allowed=*/true},
      {"about:blank", "https://foo.com",
       /*expect_allowed=*/true},

      // Extensions are exempt from checking the embedder chain.
      {"chrome-extension://some-extension", "http://not-secure.com",
       /*expect_allowed=*/true},

      // Insecure-origins that should be blocked.
      {"http://foo.com", "file://some-file",
       /*expect_allowed=*/false},
      {"fake://foo.com", "about:blank",
       /*expect_allowed=*/false},
      {"http://localhost", "http://foo.com",
       /*expect_allowed=*/false},
      {"http://localhost", "foo.com",
       /*expect_allowed=*/false},
      {"http://bar.com", "https://foo.com",
       /*expect_permission_allowed=*/false},
      {"https://foo.com", "http://bar.com",
       /*expect_permission_allowed=*/false},
      {"http://localhost", "http://foo.com",
       /*expect_permission_allowed=*/false},
      {"http://foo.com", "http://localhost",
       /*expect_permission_allowed=*/false},
      {"bar.com", "https://foo.com", /*expect_permission_allowed=*/false},
      {"https://foo.com", "bar.com", /*expect_permission_allowed=*/false}};
  for (const auto& test_case : kTestCases) {
    TestSecureOriginRestrictedPermissionContextCheck(
        test_case.requesting_url_spec, test_case.embedding_url_spec,
        test_case.expect_permission_allowed);
  }
}

TEST_F(PermissionContextBaseTests, TestParallelRequestsAllowed) {
  TestParallelRequests(CONTENT_SETTING_ALLOW);
}

TEST_F(PermissionContextBaseTests, TestParallelRequestsBlocked) {
  TestParallelRequests(CONTENT_SETTING_BLOCK);
}

TEST_F(PermissionContextBaseTests, TestParallelRequestsDismissed) {
  TestParallelRequests(CONTENT_SETTING_ASK);
}

TEST_F(PermissionContextBaseTests, TestVirtualURLDifferentOrigin) {
  TestVirtualURL(GURL("http://www.google.com"), GURL("http://foo.com"),
                 CONTENT_SETTING_BLOCK,
                 PermissionStatusSource::VIRTUAL_URL_DIFFERENT_ORIGIN);
}

TEST_F(PermissionContextBaseTests, TestVirtualURLNotHTTP) {
  TestVirtualURL(GURL("chrome://foo"), GURL("chrome://newtab"),
                 CONTENT_SETTING_ASK, PermissionStatusSource::UNSPECIFIED);
}

TEST_F(PermissionContextBaseTests, TestVirtualURLSameOrigin) {
  TestVirtualURL(GURL("http://www.google.com"),
                 GURL("http://www.google.com/foo"), CONTENT_SETTING_ASK,
                 PermissionStatusSource::UNSPECIFIED);
}

}  // namespace permissions