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

#include "components/permissions/permission_uma_util.h"

#include <cstdint>
#include <utility>

#include "base/command_line.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/no_destructor.h"
#include "base/notreached.h"
#include "base/strings/strcat.h"
#include "base/time/clock.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "components/content_settings/core/browser/content_settings_uma_util.h"
#include "components/content_settings/core/common/content_settings.h"
#include "components/content_settings/core/common/content_settings_types.h"
#include "components/content_settings/core/common/features.h"
#include "components/permissions/constants.h"
#include "components/permissions/permission_actions_history.h"
#include "components/permissions/permission_decision_auto_blocker.h"
#include "components/permissions/permission_request.h"
#include "components/permissions/permission_util.h"
#include "components/permissions/permissions_client.h"
#include "components/permissions/prediction_service/prediction_common.h"
#include "components/permissions/prediction_service/prediction_request_features.h"
#include "components/permissions/request_type.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h"
#include "printing/buildflags/buildflags.h"
#include "services/metrics/public/cpp/metrics_utils.h"
#include "services/metrics/public/cpp/ukm_builders.h"
#include "services/metrics/public/cpp/ukm_recorder.h"
#include "services/network/public/cpp/is_potentially_trustworthy.h"
#include "third_party/blink/public/common/permissions/permission_utils.h"
#include "third_party/blink/public/common/permissions_policy/permissions_policy.h"
#include "third_party/blink/public/mojom/permissions_policy/permissions_policy_feature.mojom.h"
#include "url/gurl.h"

#if BUILDFLAG(IS_ANDROID)
#include "base/android/jni_string.h"
#endif

namespace {
bool scoped_revocation_reporter_in_scope = false;
}  // namespace

namespace permissions {

#define PERMISSION_BUBBLE_TYPE_UMA(metric_name, request_type_for_uma) \
  base::UmaHistogramEnumeration(metric_name, request_type_for_uma,    \
                                RequestTypeForUma::NUM)

#define PERMISSION_BUBBLE_GESTURE_TYPE_UMA(                                  \
    gesture_metric_name, no_gesture_metric_name, gesture_type,               \
    permission_bubble_type)                                                  \
  if (gesture_type == PermissionRequestGestureType::GESTURE) {               \
    PERMISSION_BUBBLE_TYPE_UMA(gesture_metric_name, permission_bubble_type); \
  } else if (gesture_type == PermissionRequestGestureType::NO_GESTURE) {     \
    PERMISSION_BUBBLE_TYPE_UMA(no_gesture_metric_name,                       \
                               permission_bubble_type);                      \
  }

using blink::PermissionType;

namespace {

RequestTypeForUma GetUmaValueForRequestType(RequestType request_type) {
  switch (request_type) {
    case RequestType::kAccessibilityEvents:
      return RequestTypeForUma::PERMISSION_ACCESSIBILITY_EVENTS;
    case RequestType::kArSession:
      return RequestTypeForUma::PERMISSION_AR;
#if !BUILDFLAG(IS_ANDROID)
    case RequestType::kCameraPanTiltZoom:
      return RequestTypeForUma::PERMISSION_CAMERA_PAN_TILT_ZOOM;
#endif
    case RequestType::kCameraStream:
      return RequestTypeForUma::PERMISSION_MEDIASTREAM_CAMERA;
    case RequestType::kClipboard:
      return RequestTypeForUma::PERMISSION_CLIPBOARD_READ_WRITE;
    case RequestType::kDiskQuota:
      return RequestTypeForUma::QUOTA;
#if !BUILDFLAG(IS_ANDROID)
    // TODO(crbug.com/40214907): Enable on Android
    case RequestType::kLocalFonts:
      return RequestTypeForUma::PERMISSION_LOCAL_FONTS;
#endif
    case RequestType::kGeolocation:
      return RequestTypeForUma::PERMISSION_GEOLOCATION;
    case RequestType::kIdleDetection:
      return RequestTypeForUma::PERMISSION_IDLE_DETECTION;
    case RequestType::kMicStream:
      return RequestTypeForUma::PERMISSION_MEDIASTREAM_MIC;
    case RequestType::kMidiSysex:
      return RequestTypeForUma::PERMISSION_MIDI_SYSEX;
    case RequestType::kMultipleDownloads:
      return RequestTypeForUma::DOWNLOAD;
#if BUILDFLAG(IS_ANDROID)
    case RequestType::kNfcDevice:
      return RequestTypeForUma::PERMISSION_NFC;
#endif
    case RequestType::kNotifications:
      return RequestTypeForUma::PERMISSION_NOTIFICATIONS;
#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_WIN)
    case RequestType::kProtectedMediaIdentifier:
      return RequestTypeForUma::PERMISSION_PROTECTED_MEDIA_IDENTIFIER;
#endif
#if !BUILDFLAG(IS_ANDROID)
    case RequestType::kRegisterProtocolHandler:
      return RequestTypeForUma::REGISTER_PROTOCOL_HANDLER;
#endif
#if BUILDFLAG(IS_CHROMEOS)
    case RequestType::kSmartCard:
      return RequestTypeForUma::PERMISSION_SMART_CARD;
#endif
    case RequestType::kStorageAccess:
      return RequestTypeForUma::PERMISSION_STORAGE_ACCESS;
    case RequestType::kVrSession:
      return RequestTypeForUma::PERMISSION_VR;
#if BUILDFLAG(IS_CHROMEOS) && BUILDFLAG(USE_CUPS)
    case RequestType::kWebPrinting:
      return RequestTypeForUma::PERMISSION_WEB_PRINTING;
#endif
#if !BUILDFLAG(IS_ANDROID)
    case RequestType::kWindowManagement:
      return RequestTypeForUma::PERMISSION_WINDOW_MANAGEMENT;
#endif
    case RequestType::kTopLevelStorageAccess:
      return RequestTypeForUma::PERMISSION_TOP_LEVEL_STORAGE_ACCESS;
#if !BUILDFLAG(IS_ANDROID)
    case RequestType::kFileSystemAccess:
      return RequestTypeForUma::PERMISSION_FILE_SYSTEM_ACCESS;
    case RequestType::kCapturedSurfaceControl:
      return RequestTypeForUma::CAPTURED_SURFACE_CONTROL;
#endif
    case RequestType::kIdentityProvider:
      return RequestTypeForUma::PERMISSION_IDENTITY_PROVIDER;
  }
}

const int kPriorCountCap = 10;

std::string GetPermissionRequestString(RequestTypeForUma type) {
  switch (type) {
    case RequestTypeForUma::MULTIPLE:
      return "AudioAndVideoCapture";
    case RequestTypeForUma::QUOTA:
      return "Quota";
    case RequestTypeForUma::DOWNLOAD:
      return "MultipleDownload";
    case RequestTypeForUma::REGISTER_PROTOCOL_HANDLER:
      return "RegisterProtocolHandler";
    case RequestTypeForUma::PERMISSION_GEOLOCATION:
      return "Geolocation";
    case RequestTypeForUma::PERMISSION_MIDI_SYSEX:
      return "MidiSysEx";
    case RequestTypeForUma::PERMISSION_NOTIFICATIONS:
      return "Notifications";
    case RequestTypeForUma::PERMISSION_PROTECTED_MEDIA_IDENTIFIER:
      return "ProtectedMedia";
    case RequestTypeForUma::PERMISSION_MEDIASTREAM_MIC:
      return "AudioCapture";
    case RequestTypeForUma::PERMISSION_MEDIASTREAM_CAMERA:
      return "VideoCapture";
    case RequestTypeForUma::PERMISSION_PAYMENT_HANDLER:
      return "PaymentHandler";
    case RequestTypeForUma::PERMISSION_NFC:
      return "Nfc";
    case RequestTypeForUma::PERMISSION_CLIPBOARD_READ_WRITE:
      return "ClipboardReadWrite";
    case RequestTypeForUma::PERMISSION_VR:
      return "VR";
    case RequestTypeForUma::PERMISSION_AR:
      return "AR";
    case RequestTypeForUma::PERMISSION_STORAGE_ACCESS:
      return "StorageAccess";
    case RequestTypeForUma::PERMISSION_TOP_LEVEL_STORAGE_ACCESS:
      return "TopLevelStorageAccess";
    case RequestTypeForUma::PERMISSION_CAMERA_PAN_TILT_ZOOM:
      return "CameraPanTiltZoom";
    case RequestTypeForUma::PERMISSION_WINDOW_MANAGEMENT:
      return "WindowManagement";
    case RequestTypeForUma::PERMISSION_LOCAL_FONTS:
      return "LocalFonts";
    case RequestTypeForUma::PERMISSION_IDLE_DETECTION:
      return "IdleDetection";
    case RequestTypeForUma::PERMISSION_ACCESSIBILITY_EVENTS:
      return "AccessibilityEvents";
    case RequestTypeForUma::PERMISSION_FILE_SYSTEM_ACCESS:
      return "FileSystemAccess";
    case RequestTypeForUma::CAPTURED_SURFACE_CONTROL:
      return "CapturedSurfaceControl";
    case RequestTypeForUma::PERMISSION_SMART_CARD:
      return "SmartCard";
    case RequestTypeForUma::PERMISSION_WEB_PRINTING:
      return "WebPrinting";
    case RequestTypeForUma::PERMISSION_IDENTITY_PROVIDER:
      return "IdentityProvider";

    case RequestTypeForUma::UNKNOWN:
    case RequestTypeForUma::PERMISSION_FLASH:
    case RequestTypeForUma::PERMISSION_FILE_HANDLING:
    case RequestTypeForUma::NUM:
      NOTREACHED();
      return "";
  }
}

// Helper to check if the current render frame host is cross-origin with top
// level frame. Note: in case of nested frames like A(B(A)), the bottom frame A
// will get |IsCrossOriginSubframe| returns false.
bool IsCrossOriginSubframe(content::RenderFrameHost* render_frame_host) {
  DCHECK(render_frame_host);

  // Permissions are denied for fenced frames and other inner pages.
  // |GetMainFrame| should be enough to get top level frame.
  auto current_origin = render_frame_host->GetLastCommittedOrigin();
  return !render_frame_host->GetMainFrame()
              ->GetLastCommittedOrigin()
              .IsSameOriginWith(current_origin);
}

// Helper to check if the current render frame host is cross-origin with any of
// its parents.
bool IsCrossOriginWithAnyParent(content::RenderFrameHost* render_frame_host) {
  const url::Origin& current_origin =
      render_frame_host->GetLastCommittedOrigin();
  content::RenderFrameHost* parent = render_frame_host->GetParent();
  while (parent) {
    const url::Origin& parent_origin = parent->GetLastCommittedOrigin();
    if (!parent_origin.IsSameOriginWith(current_origin)) {
      return true;
    }
    parent = parent->GetParent();
  }
  return false;
}

// Helper to get permission policy header policy for the top-level frame.
// render_frame_host could be the top-level frame or a descendant of top-level
// frame.
PermissionHeaderPolicyForUMA GetTopLevelPermissionHeaderPolicyForUMA(
    content::RenderFrameHost* render_frame_host,
    blink::mojom::PermissionsPolicyFeature feature) {
  const auto& parsed_permission_policy_header =
      render_frame_host->GetMainFrame()->GetPermissionsPolicyHeader();
  if (parsed_permission_policy_header.empty()) {
    return PermissionHeaderPolicyForUMA::HEADER_NOT_PRESENT_OR_INVALID;
  }

  const auto* permissions_policy =
      render_frame_host->GetMainFrame()->GetPermissionsPolicy();
  const auto& allowlists = permissions_policy->allowlists();
  auto allowlist = allowlists.find(feature);
  if (allowlist == allowlists.end()) {
    return PermissionHeaderPolicyForUMA::FEATURE_NOT_PRESENT;
  }

  if (allowlist->second.MatchesAll()) {
    return PermissionHeaderPolicyForUMA::FEATURE_ALLOWLIST_IS_WILDCARD;
  }

  const auto& origin = render_frame_host->GetLastCommittedOrigin();
  return allowlist->second.Contains(origin)
             ? PermissionHeaderPolicyForUMA::
                   FEATURE_ALLOWLIST_EXPLICITLY_MATCHES_ORIGIN
             : PermissionHeaderPolicyForUMA::
                   FEATURE_ALLOWLIST_DOES_NOT_MATCH_ORIGIN;
}

void RecordEngagementMetric(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    content::WebContents* web_contents,
    const std::string& action) {
  CHECK(!requests.empty());

  RequestTypeForUma type =
      GetUmaValueForRequestType(requests[0]->request_type());
  if (requests.size() > 1)
    type = RequestTypeForUma::MULTIPLE;

  DCHECK(action == "Accepted" || action == "Denied" || action == "Dismissed" ||
         action == "Ignored" || action == "AcceptedOnce");
  std::string name = "Permissions.Engagement." + action + '.' +
                     GetPermissionRequestString(type);

  double engagement_score = PermissionsClient::Get()->GetSiteEngagementScore(
      web_contents->GetBrowserContext(), requests[0]->requesting_origin());
  base::UmaHistogramPercentageObsoleteDoNotUse(name, engagement_score);
}

// Records in a UMA histogram whether we should expect to see an event in UKM,
// to allow for evaluating if the current constraints on UKM recording work well
// in practice.
void RecordUmaForWhetherRevocationUkmWasRecorded(
    ContentSettingsType permission_type,
    bool has_source_id) {
  if (permission_type == ContentSettingsType::NOTIFICATIONS) {
    base::UmaHistogramBoolean(
        "Permissions.Revocation.Notifications.DidRecordUkm", has_source_id);
  }
}

// Records in a UMA histogram whether we should expect to see an event in UKM,
// to allow for evaluating if the current constraints on UKM recording work well
// in practice.
void RecordUmaForWhetherUsageUkmWasRecorded(ContentSettingsType permission_type,
                                            bool has_source_id) {
  if (permission_type == ContentSettingsType::NOTIFICATIONS) {
    base::UmaHistogramBoolean("Permissions.Usage.Notifications.DidRecordUkm",
                              has_source_id);
  }
}

void RecordUmaForRevocationSourceUI(ContentSettingsType permission_type,
                                    PermissionSourceUI source_ui) {
  if (permission_type == ContentSettingsType::NOTIFICATIONS) {
    base::UmaHistogramEnumeration(
        "Permissions.Revocation.Notifications.SourceUI", source_ui);
  }
}

void RecordPermissionUsageUkm(ContentSettingsType permission_type,
                              std::optional<ukm::SourceId> source_id) {
  RecordUmaForWhetherUsageUkmWasRecorded(permission_type,
                                         source_id.has_value());
  if (!source_id.has_value())
    return;

  ukm::builders::PermissionUsage builder(source_id.value());
  builder.SetPermissionType(static_cast<int64_t>(
      content_settings_uma_util::ContentSettingTypeToHistogramValue(
          permission_type)));
  builder.Record(ukm::UkmRecorder::Get());
}

void RecordPermissionActionUkm(
    PermissionAction action,
    PermissionRequestGestureType gesture_type,
    ContentSettingsType permission,
    int dismiss_count,
    int ignore_count,
    PermissionSourceUI source_ui,
    base::TimeDelta time_to_decision,
    PermissionPromptDisposition ui_disposition,
    std::optional<PermissionPromptDispositionReason> ui_reason,
    std::optional<std::vector<ElementAnchoredBubbleVariant>> variants,
    std::optional<bool> has_three_consecutive_denies,
    std::optional<bool> has_previously_revoked_permission,
    std::optional<PermissionUmaUtil::PredictionGrantLikelihood>
        predicted_grant_likelihood,
    PredictionRequestFeatures::ActionCounts
        loud_ui_actions_counts_for_request_type,
    PredictionRequestFeatures::ActionCounts loud_ui_actions_counts,
    PredictionRequestFeatures::ActionCounts actions_counts_for_request_type,
    PredictionRequestFeatures::ActionCounts actions_counts,
    std::optional<bool> prediction_decision_held_back,
    std::optional<ukm::SourceId> source_id) {
  if (action == PermissionAction::REVOKED) {
    RecordUmaForWhetherRevocationUkmWasRecorded(permission,
                                                source_id.has_value());
  }

  // Only record the permission change if the origin is in the history.
  if (!source_id.has_value())
    return;

  const int loud_ui_prompts_count_for_request_type =
      loud_ui_actions_counts_for_request_type.total();
  const int loud_ui_prompts_count = loud_ui_actions_counts.total();
  const int prompts_count_for_request_type =
      actions_counts_for_request_type.total();
  const int prompts_count = actions_counts.total();
  ukm::builders::Permission builder(source_id.value());
  builder.SetAction(static_cast<int64_t>(action))
      .SetGesture(static_cast<int64_t>(gesture_type))
      .SetPermissionType(static_cast<int64_t>(
          content_settings_uma_util::ContentSettingTypeToHistogramValue(
              permission)))
      .SetPriorDismissals(std::min(kPriorCountCap, dismiss_count))
      .SetPriorIgnores(std::min(kPriorCountCap, ignore_count))
      .SetSource(static_cast<int64_t>(source_ui))
      .SetPromptDisposition(static_cast<int64_t>(ui_disposition));

  builder
      .SetStats_LoudPromptsOfType_DenyRate(
          GetRoundedRatioForUkm(loud_ui_actions_counts_for_request_type.denies,
                                loud_ui_prompts_count_for_request_type))
      .SetStats_LoudPromptsOfType_DismissRate(GetRoundedRatioForUkm(
          loud_ui_actions_counts_for_request_type.dismissals,
          loud_ui_prompts_count_for_request_type))
      .SetStats_LoudPromptsOfType_GrantRate(
          GetRoundedRatioForUkm(loud_ui_actions_counts_for_request_type.grants,
                                loud_ui_prompts_count_for_request_type))
      .SetStats_LoudPromptsOfType_IgnoreRate(
          GetRoundedRatioForUkm(loud_ui_actions_counts_for_request_type.ignores,
                                loud_ui_prompts_count_for_request_type))
      .SetStats_LoudPromptsOfType_Count(
          BucketizeValue(loud_ui_prompts_count_for_request_type));

  builder
      .SetStats_LoudPrompts_DenyRate(GetRoundedRatioForUkm(
          loud_ui_actions_counts.denies, loud_ui_prompts_count))
      .SetStats_LoudPrompts_DismissRate(GetRoundedRatioForUkm(
          loud_ui_actions_counts.dismissals, loud_ui_prompts_count))
      .SetStats_LoudPrompts_GrantRate(GetRoundedRatioForUkm(
          loud_ui_actions_counts.grants, loud_ui_prompts_count))
      .SetStats_LoudPrompts_IgnoreRate(GetRoundedRatioForUkm(
          loud_ui_actions_counts.ignores, loud_ui_prompts_count))
      .SetStats_LoudPrompts_Count(BucketizeValue(loud_ui_prompts_count));

  builder
      .SetStats_AllPromptsOfType_DenyRate(
          GetRoundedRatioForUkm(actions_counts_for_request_type.denies,
                                prompts_count_for_request_type))
      .SetStats_AllPromptsOfType_DismissRate(
          GetRoundedRatioForUkm(actions_counts_for_request_type.dismissals,
                                prompts_count_for_request_type))
      .SetStats_AllPromptsOfType_GrantRate(
          GetRoundedRatioForUkm(actions_counts_for_request_type.grants,
                                prompts_count_for_request_type))
      .SetStats_AllPromptsOfType_IgnoreRate(
          GetRoundedRatioForUkm(actions_counts_for_request_type.ignores,
                                prompts_count_for_request_type))
      .SetStats_AllPromptsOfType_Count(
          BucketizeValue(prompts_count_for_request_type));

  builder
      .SetStats_AllPrompts_DenyRate(
          GetRoundedRatioForUkm(actions_counts.denies, prompts_count))
      .SetStats_AllPrompts_DismissRate(
          GetRoundedRatioForUkm(actions_counts.dismissals, prompts_count))
      .SetStats_AllPrompts_GrantRate(
          GetRoundedRatioForUkm(actions_counts.grants, prompts_count))
      .SetStats_AllPrompts_IgnoreRate(
          GetRoundedRatioForUkm(actions_counts.ignores, prompts_count))
      .SetStats_AllPrompts_Count(BucketizeValue(prompts_count));

  if (ui_reason.has_value())
    builder.SetPromptDispositionReason(static_cast<int64_t>(ui_reason.value()));

  if (predicted_grant_likelihood.has_value()) {
    builder.SetPredictionsApiResponse_GrantLikelihood(
        static_cast<int64_t>(predicted_grant_likelihood.value()));
  }

  if (prediction_decision_held_back.has_value()) {
    builder.SetPredictionsApiResponse_Heldback(
        prediction_decision_held_back.value());
  }

  if (has_three_consecutive_denies.has_value()) {
    int64_t satisfied_adaptive_triggers = 0;
    if (has_three_consecutive_denies.value())
      satisfied_adaptive_triggers |=
          static_cast<int64_t>(AdaptiveTriggers::THREE_CONSECUTIVE_DENIES);
    builder.SetSatisfiedAdaptiveTriggers(satisfied_adaptive_triggers);
  }

  if (has_previously_revoked_permission.has_value()) {
    int64_t previously_revoked_permission = 0;
    if (has_previously_revoked_permission.value()) {
      previously_revoked_permission = static_cast<int64_t>(
          PermissionAutoRevocationHistory::PREVIOUSLY_AUTO_REVOKED);
    }
    builder.SetPermissionAutoRevocationHistory(previously_revoked_permission);
  }

  if (ui_disposition == PermissionPromptDisposition::ELEMENT_ANCHORED_BUBBLE &&
      variants.has_value()) {
    // Variant can have a maximum of 3 values, one per site level and 2 for OS
    // level.
    CHECK_LE(variants->size(), 3U);

    const std::vector<ElementAnchoredBubbleVariant>& variant_array =
        variants.value();

    for (ElementAnchoredBubbleVariant variant : variant_array) {
      switch (variant) {
        case ElementAnchoredBubbleVariant::ADMINISTRATOR_GRANTED:
        case ElementAnchoredBubbleVariant::PREVIOUSLY_GRANTED:
        case ElementAnchoredBubbleVariant::ASK:
        case ElementAnchoredBubbleVariant::PREVIOUSLY_DENIED:
        case ElementAnchoredBubbleVariant::ADMINISTRATOR_DENIED:
          builder.SetSiteLevelScreen(static_cast<int64_t>(variant));
          break;
        case ElementAnchoredBubbleVariant::OS_PROMPT:
          builder.SetOsPromptScreen(static_cast<int64_t>(variant));
          break;

        case ElementAnchoredBubbleVariant::OS_SYSTEM_SETTINGS:
          builder.SetOsSystemSettingsScreen(static_cast<int64_t>(variant));
          break;
        case ElementAnchoredBubbleVariant::UNINITIALIZED:
          break;
      }
    }
  }
  if (!time_to_decision.is_zero()) {
    builder.SetTimeToDecision(ukm::GetExponentialBucketMinForUserTiming(
        time_to_decision.InMilliseconds()));
  }

  builder.Record(ukm::UkmRecorder::Get());
}

// |full_version| represented in the format `YYYY.M.D.m`, where m is the
// minute-of-day. Return int represented in the format `YYYYMMDD`.
// CrowdDeny versions published before 2020 will be reported as 1.
// Returns 0 if no version available.
// Returns 1 if a version has invalid format.
int ConvertCrowdDenyVersionToInt(const std::optional<base::Version>& version) {
  if (!version.has_value() || !version.value().IsValid())
    return 0;

  const std::vector<uint32_t>& full_version = version.value().components();
  if (full_version.size() != 4)
    return 1;

  const int kCrowdDenyMinYearLimit = 2020;
  const int year = base::checked_cast<int>(full_version.at(0));
  if (year < kCrowdDenyMinYearLimit)
    return 1;

  const int month = base::checked_cast<int>(full_version.at(1));
  const int day = base::checked_cast<int>(full_version.at(2));

  int short_version = year;

  short_version *= 100;
  short_version += month;
  short_version *= 100;
  short_version += day;

  return short_version;
}

AutoDSEPermissionRevertTransition GetAutoDSEPermissionRevertedTransition(
    ContentSetting backed_up_setting,
    ContentSetting effective_setting,
    ContentSetting end_state_setting) {
  if (backed_up_setting == CONTENT_SETTING_ASK &&
      effective_setting == CONTENT_SETTING_ALLOW &&
      end_state_setting == CONTENT_SETTING_ASK) {
    return AutoDSEPermissionRevertTransition::NO_DECISION_ASK;
  } else if (backed_up_setting == CONTENT_SETTING_ALLOW &&
             effective_setting == CONTENT_SETTING_ALLOW &&
             end_state_setting == CONTENT_SETTING_ALLOW) {
    return AutoDSEPermissionRevertTransition::PRESERVE_ALLOW;
  } else if (backed_up_setting == CONTENT_SETTING_BLOCK &&
             effective_setting == CONTENT_SETTING_ALLOW &&
             end_state_setting == CONTENT_SETTING_ASK) {
    return AutoDSEPermissionRevertTransition::CONFLICT_ASK;
  } else if (backed_up_setting == CONTENT_SETTING_ASK &&
             effective_setting == CONTENT_SETTING_BLOCK &&
             end_state_setting == CONTENT_SETTING_BLOCK) {
    return AutoDSEPermissionRevertTransition::PRESERVE_BLOCK_ASK;
  } else if (backed_up_setting == CONTENT_SETTING_ALLOW &&
             effective_setting == CONTENT_SETTING_BLOCK &&
             end_state_setting == CONTENT_SETTING_BLOCK) {
    return AutoDSEPermissionRevertTransition::PRESERVE_BLOCK_ALLOW;
  } else if (backed_up_setting == CONTENT_SETTING_BLOCK &&
             effective_setting == CONTENT_SETTING_BLOCK &&
             end_state_setting == CONTENT_SETTING_BLOCK) {
    return AutoDSEPermissionRevertTransition::PRESERVE_BLOCK_BLOCK;
  } else {
    return AutoDSEPermissionRevertTransition::INVALID_END_STATE;
  }
}

void RecordTopLevelPermissionsHeaderPolicy(
    ContentSettingsType content_settings_type,
    const std::string& histogram,
    content::RenderFrameHost* render_frame_host) {
  DCHECK(IsCrossOriginSubframe(render_frame_host));

  // We only care about about permission types that have a corresponding
  // permission policy
  const auto feature =
      PermissionUtil::GetPermissionsPolicyFeature(content_settings_type);
  if (!feature.has_value()) {
    return;
  }

  // This function will only be called when we use/prompt a permission requested
  // from a cross-origin subframe. Being allowed by permission policy is a
  // necessary condition to use a permission in sub-frame.
  DCHECK(render_frame_host->IsFeatureEnabled(feature.value()));
  base::UmaHistogramEnumeration(histogram,
                                GetTopLevelPermissionHeaderPolicyForUMA(
                                    render_frame_host, feature.value()),
                                PermissionHeaderPolicyForUMA::NUM);
}

PermissionChangeInfo GetChangeInfo(bool is_used,
                                   bool show_infobar,
                                   bool page_reload) {
  if (show_infobar) {
    if (page_reload) {
      if (is_used) {
        return PermissionChangeInfo::kInfobarShownPageReloadPermissionUsed;
      } else {
        return PermissionChangeInfo::kInfobarShownPageReloadPermissionNotUsed;
      }

    } else {
      if (is_used) {
        return PermissionChangeInfo::kInfobarShownNoPageReloadPermissionUsed;
      } else {
        return PermissionChangeInfo::kInfobarShownNoPageReloadPermissionNotUsed;
      }
    }
  } else {
    if (page_reload) {
      if (is_used) {
        return PermissionChangeInfo::kInfobarNotShownPageReloadPermissionUsed;
      } else {
        return PermissionChangeInfo::
            kInfobarNotShownPageReloadPermissionNotUsed;
      }

    } else {
      if (is_used) {
        return PermissionChangeInfo::kInfobarNotShownNoPageReloadPermissionUsed;
      } else {
        return PermissionChangeInfo::
            kInfobarNotShownNoPageReloadPermissionNotUsed;
      }
    }
  }
}

}  // anonymous namespace

// PermissionUmaUtil ----------------------------------------------------------

const char PermissionUmaUtil::kPermissionsPromptShown[] =
    "Permissions.Prompt.Shown";
const char PermissionUmaUtil::kPermissionsPromptShownGesture[] =
    "Permissions.Prompt.Shown.Gesture";
const char PermissionUmaUtil::kPermissionsPromptShownNoGesture[] =
    "Permissions.Prompt.Shown.NoGesture";
const char PermissionUmaUtil::kPermissionsPromptAccepted[] =
    "Permissions.Prompt.Accepted";
const char PermissionUmaUtil::kPermissionsPromptAcceptedGesture[] =
    "Permissions.Prompt.Accepted.Gesture";
const char PermissionUmaUtil::kPermissionsPromptAcceptedNoGesture[] =
    "Permissions.Prompt.Accepted.NoGesture";
const char PermissionUmaUtil::kPermissionsPromptAcceptedOnce[] =
    "Permissions.Prompt.AcceptedOnce";
const char PermissionUmaUtil::kPermissionsPromptAcceptedOnceGesture[] =
    "Permissions.Prompt.AcceptedOnce.Gesture";
const char PermissionUmaUtil::kPermissionsPromptAcceptedOnceNoGesture[] =
    "Permissions.Prompt.AcceptedOnce.NoGesture";
const char PermissionUmaUtil::kPermissionsPromptDenied[] =
    "Permissions.Prompt.Denied";
const char PermissionUmaUtil::kPermissionsPromptDeniedGesture[] =
    "Permissions.Prompt.Denied.Gesture";
const char PermissionUmaUtil::kPermissionsPromptDeniedNoGesture[] =
    "Permissions.Prompt.Denied.NoGesture";
const char PermissionUmaUtil::kPermissionsExperimentalUsagePrefix[] =
    "Permissions.Experimental.Usage.";
const char PermissionUmaUtil::kPermissionsActionPrefix[] =
    "Permissions.Action.";

// Make sure you update histograms.xml permission histogram_suffix if you
// add new permission
void PermissionUmaUtil::PermissionRequested(ContentSettingsType content_type) {
  PermissionType permission;
  bool success = PermissionUtil::GetPermissionType(content_type, &permission);
  DCHECK(success);

  base::UmaHistogramEnumeration("ContentSettings.PermissionRequested",
                                permission, PermissionType::NUM);
}

void PermissionUmaUtil::RecordActivityIndicator(
    std::set<ContentSettingsType> permissions,
    bool blocked,
    bool blocked_system_level,
    bool clicked) {
  DCHECK(!permissions.empty());
  DCHECK(permissions.contains(ContentSettingsType::MEDIASTREAM_CAMERA) ||
         permissions.contains(ContentSettingsType::MEDIASTREAM_MIC));

  ActivityIndicatorState state;
  if (blocked) {
    if (blocked_system_level) {
      state = ActivityIndicatorState::kBlockedOnSystemLevel;
    } else {
      state = ActivityIndicatorState::kBlockedOnSiteLevel;
    }
  } else {
    state = ActivityIndicatorState::kInUse;
  }

  std::string indicators_type;

  if (permissions.size() > 1) {
    indicators_type = "AudioAndVideoCapture";
  } else if (permissions.contains(ContentSettingsType::MEDIASTREAM_CAMERA)) {
    indicators_type = "VideoCapture";
  } else {
    indicators_type = "AudioCapture";
  }

  std::string action;
  if (clicked) {
    action = "Click";
  } else {
    action = "Show";
  }

  base::UmaHistogramEnumeration(
      "Permissions.ActivityIndicator.LHS." + indicators_type + "." + action,
      state);
}

void PermissionUmaUtil::RecordDismissalType(
    const std::vector<ContentSettingsType>& content_settings_types,
    PermissionPromptDisposition ui_disposition,
    DismissalType dismissalType) {
  RequestTypeForUma type = GetUmaValueForRequestType(
      ContentSettingsTypeToRequestType(content_settings_types[0]));

  if (content_settings_types.size() > 1) {
    type = RequestTypeForUma::MULTIPLE;
  }

  std::string permission_type = GetPermissionRequestString(type);
  std::string permission_disposition =
      GetPromptDispositionString(ui_disposition);
  base::UmaHistogramEnumeration("Permissions.Prompt." + permission_type + "." +
                                    permission_disposition +
                                    ".Dismissed.Method",
                                dismissalType);
}

void PermissionUmaUtil::RecordPermissionRequestedFromFrame(
    ContentSettingsType content_settings_type,
    content::RenderFrameHost* rfh) {
  PermissionType permission;
  bool success =
      PermissionUtil::GetPermissionType(content_settings_type, &permission);
  DCHECK(success);

  if (IsCrossOriginWithAnyParent(rfh)) {
    base::UmaHistogramEnumeration("Permissions.Request.CrossOrigin", permission,
                                  PermissionType::NUM);
  } else {
    std::string frame_level =
        rfh->IsInPrimaryMainFrame() ? "MainFrame" : "SubFrame";

    base::UmaHistogramEnumeration(
        "Permissions.Request.SameOrigin." + frame_level, permission,
        PermissionType::NUM);
  }
}

void PermissionUmaUtil::PermissionRequestPreignored(PermissionType permission) {
  base::UmaHistogramEnumeration("Permissions.QuietPrompt.Preignore", permission,
                                PermissionType::NUM);
}

void PermissionUmaUtil::PermissionRevoked(
    ContentSettingsType permission,
    PermissionSourceUI source_ui,
    const GURL& revoked_origin,
    content::BrowserContext* browser_context) {
  DCHECK(PermissionUtil::IsPermission(permission));
  // An unknown gesture type is passed in since gesture type is only
  // applicable in prompt UIs where revocations are not possible.
  RecordPermissionAction(permission, PermissionAction::REVOKED, source_ui,
                         PermissionRequestGestureType::UNKNOWN,
                         /*time_to_decision=*/base::TimeDelta(),
                         PermissionPromptDisposition::NOT_APPLICABLE,
                         /*ui_reason=*/std::nullopt, /*variants=*/std::nullopt,
                         revoked_origin,
                         /*web_contents=*/nullptr, browser_context,
                         /*render_frame_host*/ nullptr,
                         /*predicted_grant_likelihood=*/std::nullopt,
                         /*prediction_decision_held_back=*/std::nullopt);
}

void PermissionUmaUtil::RecordEmbargoPromptSuppression(
    PermissionEmbargoStatus embargo_status) {
  base::UmaHistogramEnumeration(
      "Permissions.AutoBlocker.EmbargoPromptSuppression", embargo_status,
      PermissionEmbargoStatus::NUM);
}

void PermissionUmaUtil::RecordEmbargoPromptSuppressionFromSource(
    content::PermissionStatusSource source) {
  // Explicitly switch to ensure that any new
  // PermissionStatusSource values are dealt with appropriately.
  switch (source) {
    case content::PermissionStatusSource::MULTIPLE_DISMISSALS:
      PermissionUmaUtil::RecordEmbargoPromptSuppression(
          PermissionEmbargoStatus::REPEATED_DISMISSALS);
      break;
    case content::PermissionStatusSource::MULTIPLE_IGNORES:
      PermissionUmaUtil::RecordEmbargoPromptSuppression(
          PermissionEmbargoStatus::REPEATED_IGNORES);
      break;
    case content::PermissionStatusSource::RECENT_DISPLAY:
      PermissionUmaUtil::RecordEmbargoPromptSuppression(
          PermissionEmbargoStatus::RECENT_DISPLAY);
      break;
    case content::PermissionStatusSource::UNSPECIFIED:
    case content::PermissionStatusSource::KILL_SWITCH:
    case content::PermissionStatusSource::INSECURE_ORIGIN:
    case content::PermissionStatusSource::FEATURE_POLICY:
    case content::PermissionStatusSource::VIRTUAL_URL_DIFFERENT_ORIGIN:
    case content::PermissionStatusSource::FENCED_FRAME:
      // The permission wasn't under embargo, so don't record anything. We may
      // embargo it later.
      break;
  }
}

void PermissionUmaUtil::RecordEmbargoStatus(
    PermissionEmbargoStatus embargo_status) {
  base::UmaHistogramEnumeration("Permissions.AutoBlocker.EmbargoStatus",
                                embargo_status, PermissionEmbargoStatus::NUM);
}

void PermissionUmaUtil::RecordPermissionRecoverySuccessRate(
    ContentSettingsType permission,
    bool is_used,
    bool show_infobar,
    bool page_reload) {
  PermissionChangeInfo change_info =
      GetChangeInfo(is_used, show_infobar, page_reload);

  std::string permission_string = GetPermissionRequestString(
      GetUmaValueForRequestType(ContentSettingsTypeToRequestType(permission)));

  base::UmaHistogramEnumeration("Permissions.PageInfo.Changed." +
                                    permission_string + ".Reallowed.Outcome",
                                change_info);
}

void PermissionUmaUtil::RecordPermissionPromptAttempt(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    bool IsLocationBarEditingOrEmpty) {
  DCHECK(!requests.empty());

  RequestTypeForUma request_type = RequestTypeForUma::MULTIPLE;
  PermissionRequestGestureType gesture_type =
      PermissionRequestGestureType::UNKNOWN;
  if (requests.size() == 1) {
    request_type = GetUmaValueForRequestType(requests[0]->request_type());
    gesture_type = requests[0]->GetGestureType();
  }

  std::string permission_type = GetPermissionRequestString(request_type);

  std::string gesture;

  switch (gesture_type) {
    case PermissionRequestGestureType::UNKNOWN: {
      gesture = "Unknown";
      break;
    }
    case PermissionRequestGestureType::GESTURE: {
      gesture = "Gesture";
      break;
    }
    case PermissionRequestGestureType::NO_GESTURE: {
      gesture = "NoGesture";
      break;
    }
    default:
      NOTREACHED();
  }

  std::string histogram_name =
      "Permissions.Prompt." + permission_type + "." + gesture + ".Attempt";

  base::UmaHistogramBoolean(histogram_name, IsLocationBarEditingOrEmpty);
}

void PermissionUmaUtil::PermissionPromptShown(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>&
        requests) {
  DCHECK(!requests.empty());

  RequestTypeForUma request_type = RequestTypeForUma::MULTIPLE;
  PermissionRequestGestureType gesture_type =
      PermissionRequestGestureType::UNKNOWN;
  if (requests.size() == 1) {
    request_type = GetUmaValueForRequestType(requests[0]->request_type());
    gesture_type = requests[0]->GetGestureType();
  }

  PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptShown, request_type);
  PERMISSION_BUBBLE_GESTURE_TYPE_UMA(kPermissionsPromptShownGesture,
                                     kPermissionsPromptShownNoGesture,
                                     gesture_type, request_type);
}

void PermissionUmaUtil::PermissionPromptResolved(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    content::WebContents* web_contents,
    PermissionAction permission_action,
    base::TimeDelta time_to_decision,
    PermissionPromptDisposition ui_disposition,
    std::optional<PermissionPromptDispositionReason> ui_reason,
    std::optional<std::vector<ElementAnchoredBubbleVariant>> variants,
    std::optional<PredictionGrantLikelihood> predicted_grant_likelihood,
    std::optional<bool> prediction_decision_held_back,
    std::optional<permissions::PermissionIgnoredReason> ignored_reason,
    bool did_show_prompt,
    bool did_click_managed,
    bool did_click_learn_more) {
  switch (permission_action) {
    case PermissionAction::GRANTED:
      RecordPromptDecided(requests, /*accepted=*/true, /*is_one_time=*/false);
      break;
    case PermissionAction::DENIED:
      RecordPromptDecided(requests, /*accepted=*/false, /*is_one_time*/ false);
      break;
    case PermissionAction::DISMISSED:
    case PermissionAction::IGNORED:
      RecordIgnoreReason(requests, ui_disposition,
                         ignored_reason.value_or(
                             permissions::PermissionIgnoredReason::UNKNOWN));
      break;
    case PermissionAction::GRANTED_ONCE:
      RecordPromptDecided(requests, /*accepted=*/true, /*is_one_time*/ true);
      break;
    default:
      NOTREACHED();
      break;
  }
  std::string action_string = GetPermissionActionString(permission_action);
  RecordEngagementMetric(requests, web_contents, action_string);

  PermissionDecisionAutoBlocker* autoblocker =
      PermissionsClient::Get()->GetPermissionDecisionAutoBlocker(
          web_contents->GetBrowserContext());

  for (PermissionRequest* request : requests) {
    ContentSettingsType permission = request->GetContentSettingsType();
    // TODO(timloh): We only record these metrics for permissions which have a
    // ContentSettingsType, as otherwise they don't support GetGestureType.
    if (permission == ContentSettingsType::DEFAULT)
      continue;

    PermissionRequestGestureType gesture_type = request->GetGestureType();
    const GURL& requesting_origin = request->requesting_origin();

    RecordPermissionAction(
        permission, permission_action, PermissionSourceUI::PROMPT, gesture_type,
        time_to_decision, ui_disposition, ui_reason, variants,
        requesting_origin, web_contents, web_contents->GetBrowserContext(),
        content::RenderFrameHost::FromID(request->get_requesting_frame_id()),
        predicted_grant_likelihood, prediction_decision_held_back);

    std::string priorDismissPrefix =
        "Permissions.Prompt." + action_string + ".PriorDismissCount2.";
    std::string priorIgnorePrefix =
        "Permissions.Prompt." + action_string + ".PriorIgnoreCount2.";
    RecordPermissionPromptPriorCount(
        permission, priorDismissPrefix,
        autoblocker->GetDismissCount(requesting_origin, permission));
    RecordPermissionPromptPriorCount(
        permission, priorIgnorePrefix,
        autoblocker->GetIgnoreCount(requesting_origin, permission));
  }

  base::UmaHistogramEnumeration("Permissions.Action.WithDisposition." +
                                    GetPromptDispositionString(ui_disposition),
                                permission_action, PermissionAction::NUM);

  RequestTypeForUma type =
      GetUmaValueForRequestType(requests[0]->request_type());
  if (requests.size() > 1)
    type = RequestTypeForUma::MULTIPLE;

  std::string permission_type = GetPermissionRequestString(type);
  std::string permission_disposition =
      GetPromptDispositionString(ui_disposition);

  base::UmaHistogramEnumeration("Permissions.Prompt." + permission_type + "." +
                                    permission_disposition + ".Action",
                                permission_action, PermissionAction::NUM);

  if (!time_to_decision.is_zero()) {
    base::UmaHistogramLongTimes("Permissions.Prompt." + permission_type + "." +
                                    permission_disposition + "." +
                                    action_string + ".TimeToAction",
                                time_to_decision);
  }

  if (permission_action == PermissionAction::IGNORED &&
      ui_disposition !=
          PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP_AUTO_BUBBLE &&
      ui_disposition != PermissionPromptDisposition::ANCHORED_BUBBLE) {
    base::UmaHistogramBoolean("Permissions.Prompt." + permission_type + "." +
                                  permission_disposition +
                                  ".Ignored.DidShowBubble",
                              did_show_prompt);
  }

  if (requests[0]->request_type() == RequestType::kGeolocation ||
      requests[0]->request_type() == RequestType::kNotifications) {
    if (ui_disposition ==
            PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_CHIP ||
        ui_disposition == PermissionPromptDisposition::MESSAGE_UI ||
        ui_disposition == PermissionPromptDisposition::MINI_INFOBAR) {
      base::UmaHistogramBoolean("Permissions.Prompt." + permission_type + "." +
                                    permission_disposition + "." +
                                    action_string + ".DidClickManage",
                                did_click_managed);
    } else if (ui_disposition == PermissionPromptDisposition::
                                     LOCATION_BAR_LEFT_QUIET_ABUSIVE_CHIP ||
               ui_disposition == PermissionPromptDisposition::MESSAGE_UI ||
               ui_disposition == PermissionPromptDisposition::MINI_INFOBAR) {
      base::UmaHistogramBoolean("Permissions.Prompt." + permission_type + "." +
                                    permission_disposition + "." +
                                    action_string + ".DidClickLearnMore",
                                did_click_learn_more);
    }
  }
}  // namespace permissions

void PermissionUmaUtil::RecordPermissionPromptPriorCount(
    ContentSettingsType permission,
    const std::string& prefix,
    int count) {
  // The user is not prompted for this permissions, thus there is no prompt
  // event to record a prior count for.
  DCHECK_NE(ContentSettingsType::BACKGROUND_SYNC, permission);

  // Expand UMA_HISTOGRAM_COUNTS_100 so that we can use a dynamically suffixed
  // histogram name.
  base::Histogram::FactoryGet(
      prefix + PermissionUtil::GetPermissionString(permission), 1, 100, 50,
      base::HistogramBase::kUmaTargetedHistogramFlag)
      ->Add(count);
}

void PermissionUmaUtil::RecordInfobarDetailsExpanded(bool expanded) {
  base::UmaHistogramBoolean("Permissions.Prompt.Infobar.DetailsExpanded",
                            expanded);
}

void PermissionUmaUtil::RecordCrowdDenyDelayedPushNotification(
    base::TimeDelta delay) {
  base::UmaHistogramTimes(
      "Permissions.CrowdDeny.PreloadData.DelayedPushNotification", delay);
}

void PermissionUmaUtil::RecordCrowdDenyVersionAtAbuseCheckTime(
    const std::optional<base::Version>& version) {
  base::UmaHistogramSparse(
      "Permissions.CrowdDeny.PreloadData.VersionAtAbuseCheckTime",
      ConvertCrowdDenyVersionToInt(version));
}

void PermissionUmaUtil::RecordMissingPermissionInfobarShouldShow(
    bool should_show,
    const std::vector<ContentSettingsType>& content_settings_types) {
  for (const auto& content_settings_type : content_settings_types) {
    base::UmaHistogramBoolean(
        "Permissions.MissingOSLevelPermission.ShouldShow." +
            PermissionUtil::GetPermissionString(content_settings_type),
        should_show);
  }
}

void PermissionUmaUtil::RecordMissingPermissionInfobarAction(
    PermissionAction action,
    const std::vector<ContentSettingsType>& content_settings_types) {
  for (const auto& content_settings_type : content_settings_types) {
    base::UmaHistogramEnumeration(
        "Permissions.MissingOSLevelPermission.Action." +
            PermissionUtil::GetPermissionString(content_settings_type),
        action, PermissionAction::NUM);
  }
}

PermissionUmaUtil::ScopedRevocationReporter::ScopedRevocationReporter(
    content::BrowserContext* browser_context,
    const GURL& primary_url,
    const GURL& secondary_url,
    ContentSettingsType content_type,
    PermissionSourceUI source_ui)
    : browser_context_(browser_context),
      primary_url_(primary_url),
      secondary_url_(secondary_url),
      content_type_(content_type),
      source_ui_(source_ui) {
  if (!primary_url_.is_valid() ||
      (!secondary_url_.is_valid() && !secondary_url_.is_empty()) ||
      !IsRequestablePermissionType(content_type_) ||
      !PermissionUtil::IsPermission(content_type_)) {
    is_initially_allowed_ = false;
    return;
  }
  HostContentSettingsMap* settings_map =
      PermissionsClient::Get()->GetSettingsMap(browser_context_);
  ContentSetting initial_content_setting = settings_map->GetContentSetting(
      primary_url_, secondary_url_, content_type_);
  is_initially_allowed_ = initial_content_setting == CONTENT_SETTING_ALLOW;
  content_settings::SettingInfo setting_info;
  settings_map->GetWebsiteSetting(primary_url, secondary_url, content_type_,
                                  &setting_info);
  last_modified_date_ = setting_info.metadata.last_modified();
  scoped_revocation_reporter_in_scope = true;
}

PermissionUmaUtil::ScopedRevocationReporter::ScopedRevocationReporter(
    content::BrowserContext* browser_context,
    const ContentSettingsPattern& primary_pattern,
    const ContentSettingsPattern& secondary_pattern,
    ContentSettingsType content_type,
    PermissionSourceUI source_ui)
    : ScopedRevocationReporter(
          browser_context,
          GURL(primary_pattern.ToString()),
          GURL((secondary_pattern == ContentSettingsPattern::Wildcard())
                   ? primary_pattern.ToString()
                   : secondary_pattern.ToString()),
          content_type,
          source_ui) {}

PermissionUmaUtil::ScopedRevocationReporter::~ScopedRevocationReporter() {
  scoped_revocation_reporter_in_scope = false;
  if (!is_initially_allowed_)
    return;
  if (!IsRequestablePermissionType(content_type_) ||
      !PermissionUtil::IsPermission(content_type_)) {
    return;
  }
  HostContentSettingsMap* settings_map =
      PermissionsClient::Get()->GetSettingsMap(browser_context_);
  ContentSetting final_content_setting = settings_map->GetContentSetting(
      primary_url_, secondary_url_, content_type_);
  if (final_content_setting != CONTENT_SETTING_ALLOW) {
    // PermissionUmaUtil takes origins, even though they're typed as GURL.
    GURL requesting_origin = primary_url_.DeprecatedGetOriginAsURL();
    PermissionRevoked(content_type_, source_ui_, requesting_origin,
                      browser_context_);
    if ((content_type_ == ContentSettingsType::GEOLOCATION ||
         content_type_ == ContentSettingsType::MEDIASTREAM_CAMERA ||
         content_type_ == ContentSettingsType::MEDIASTREAM_MIC) &&
        !last_modified_date_.is_null()) {
      RecordTimeElapsedBetweenGrantAndRevoke(
          content_type_, base::Time::Now() - last_modified_date_);
    }
  }
}

bool PermissionUmaUtil::ScopedRevocationReporter::IsInstanceInScope() {
  return scoped_revocation_reporter_in_scope;
}

void PermissionUmaUtil::RecordPermissionUsage(
    ContentSettingsType permission_type,
    content::BrowserContext* browser_context,
    content::WebContents* web_contents,
    const GURL& requesting_origin) {
  PermissionsClient::Get()->GetUkmSourceId(
      permission_type, browser_context, web_contents, requesting_origin,
      base::BindOnce(&RecordPermissionUsageUkm, permission_type));
}

void PermissionUmaUtil::RecordPermissionAction(
    ContentSettingsType permission,
    PermissionAction action,
    PermissionSourceUI source_ui,
    PermissionRequestGestureType gesture_type,
    base::TimeDelta time_to_decision,
    PermissionPromptDisposition ui_disposition,
    std::optional<PermissionPromptDispositionReason> ui_reason,
    std::optional<std::vector<ElementAnchoredBubbleVariant>> variants,
    const GURL& requesting_origin,
    content::WebContents* web_contents,
    content::BrowserContext* browser_context,
    content::RenderFrameHost* render_frame_host,
    std::optional<PredictionGrantLikelihood> predicted_grant_likelihood,
    std::optional<bool> prediction_decision_held_back) {
  DCHECK(PermissionUtil::IsPermission(permission));
  PermissionDecisionAutoBlocker* autoblocker =
      PermissionsClient::Get()->GetPermissionDecisionAutoBlocker(
          browser_context);
  int dismiss_count =
      autoblocker->GetDismissCount(requesting_origin, permission);
  int ignore_count = autoblocker->GetIgnoreCount(requesting_origin, permission);

  const base::Time cutoff = base::Time::Now() - base::Days(28);
  PermissionActionsHistory* permission_actions_history =
      PermissionsClient::Get()->GetPermissionActionsHistory(browser_context);

  PredictionRequestFeatures::ActionCounts
      loud_ui_actions_counts_per_request_type;
  PredictionRequestFeatures::ActionCounts loud_ui_actions_counts;
  PredictionRequestFeatures::ActionCounts actions_counts_per_request_type;
  PredictionRequestFeatures::ActionCounts actions_counts;

  if (permission_actions_history != nullptr) {
    DCHECK(IsRequestablePermissionType(permission));
    auto loud_ui_actions_per_request_type =
        permission_actions_history->GetHistory(
            cutoff, ContentSettingsTypeToRequestType(permission),
            PermissionActionsHistory::EntryFilter::WANT_LOUD_PROMPTS_ONLY);
    PermissionActionsHistory::FillInActionCounts(
        &loud_ui_actions_counts_per_request_type,
        loud_ui_actions_per_request_type);

    auto loud_ui_actions = permission_actions_history->GetHistory(
        cutoff, PermissionActionsHistory::EntryFilter::WANT_LOUD_PROMPTS_ONLY);
    PermissionActionsHistory::FillInActionCounts(&loud_ui_actions_counts,
                                                 loud_ui_actions);

    auto actions_per_request_type = permission_actions_history->GetHistory(
        cutoff, ContentSettingsTypeToRequestType(permission),
        PermissionActionsHistory::EntryFilter::WANT_ALL_PROMPTS);
    PermissionActionsHistory::FillInActionCounts(
        &actions_counts_per_request_type, actions_per_request_type);

    auto actions = permission_actions_history->GetHistory(
        cutoff, PermissionActionsHistory::EntryFilter::WANT_ALL_PROMPTS);
    PermissionActionsHistory::FillInActionCounts(&actions_counts, actions);
  }

  if (action == PermissionAction::REVOKED) {
    RecordUmaForRevocationSourceUI(permission, source_ui);
  }

  PermissionsClient::Get()->GetUkmSourceId(
      permission, browser_context, web_contents, requesting_origin,
      base::BindOnce(
          &RecordPermissionActionUkm, action, gesture_type, permission,
          dismiss_count, ignore_count, source_ui, time_to_decision,
          ui_disposition, ui_reason, variants,
          permission == ContentSettingsType::NOTIFICATIONS
              ? PermissionsClient::Get()
                    ->HadThreeConsecutiveNotificationPermissionDenies(
                        browser_context)
              : std::nullopt,
          PermissionsClient::Get()->HasPreviouslyAutoRevokedPermission(
              browser_context, requesting_origin, permission),
          predicted_grant_likelihood, loud_ui_actions_counts_per_request_type,
          loud_ui_actions_counts, actions_counts_per_request_type,
          actions_counts, prediction_decision_held_back));

  if (render_frame_host && IsCrossOriginSubframe(render_frame_host)) {
    RecordCrossOriginFrameActionAndPolicyConfiguration(permission, action,
                                                       render_frame_host);
  }

  switch (permission) {
    case ContentSettingsType::GEOLOCATION:
      base::UmaHistogramEnumeration("Permissions.Action.Geolocation", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::NOTIFICATIONS:
      base::UmaHistogramEnumeration("Permissions.Action.Notifications", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::MIDI_SYSEX:
      base::UmaHistogramEnumeration("Permissions.Action.MidiSysEx", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::PROTECTED_MEDIA_IDENTIFIER:
      base::UmaHistogramEnumeration("Permissions.Action.ProtectedMedia", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::MEDIASTREAM_MIC:
      base::UmaHistogramEnumeration("Permissions.Action.AudioCapture", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::MEDIASTREAM_CAMERA:
      base::UmaHistogramEnumeration("Permissions.Action.VideoCapture", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::CLIPBOARD_READ_WRITE:
      base::UmaHistogramEnumeration("Permissions.Action.ClipboardReadWrite",
                                    action, PermissionAction::NUM);
      break;
    case ContentSettingsType::PAYMENT_HANDLER:
      base::UmaHistogramEnumeration("Permissions.Action.PaymentHandler", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::NFC:
      base::UmaHistogramEnumeration("Permissions.Action.Nfc", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::VR:
      base::UmaHistogramEnumeration("Permissions.Action.VR", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::AR:
      base::UmaHistogramEnumeration("Permissions.Action.AR", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::STORAGE_ACCESS:
      base::UmaHistogramEnumeration("Permissions.Action.StorageAccess", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::TOP_LEVEL_STORAGE_ACCESS:
      base::UmaHistogramEnumeration("Permissions.Action.TopLevelStorageAccess",
                                    action, PermissionAction::NUM);
      break;
    case ContentSettingsType::CAMERA_PAN_TILT_ZOOM:
      base::UmaHistogramEnumeration("Permissions.Action.CameraPanTiltZoom",
                                    action, PermissionAction::NUM);
      break;
    case ContentSettingsType::WINDOW_MANAGEMENT:
      base::UmaHistogramEnumeration("Permissions.Action.WindowPlacement",
                                    action, PermissionAction::NUM);
      break;
    case ContentSettingsType::LOCAL_FONTS:
      base::UmaHistogramEnumeration("Permissions.Action.LocalFonts", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::IDLE_DETECTION:
      base::UmaHistogramEnumeration("Permissions.Action.IdleDetection", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::ACCESSIBILITY_EVENTS:
      base::UmaHistogramEnumeration("Permissions.Action.AccessibilityEvents",
                                    action, PermissionAction::NUM);
      break;
    case ContentSettingsType::CAPTURED_SURFACE_CONTROL:
      base::UmaHistogramEnumeration("Permissions.Action.CapturedSurfaceControl",
                                    action, PermissionAction::NUM);
      break;
    case ContentSettingsType::SMART_CARD_DATA:
      base::UmaHistogramEnumeration("Permissions.Action.SmartCard", action,
                                    PermissionAction::NUM);
      break;
    case ContentSettingsType::WEB_PRINTING:
      base::UmaHistogramEnumeration("Permissions.Action.WebPrinting", action,
                                    PermissionAction::NUM);
      break;
    // The user is not prompted for these permissions, thus there is no
    // permission action recorded for them.
    default:
      NOTREACHED() << "PERMISSION "
                   << PermissionUtil::GetPermissionString(permission)
                   << " not accounted for";
  }
}

// static
void PermissionUmaUtil::RecordPromptDecided(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    bool accepted,
    bool is_one_time) {
  DCHECK(!requests.empty());

  RequestTypeForUma request_type = RequestTypeForUma::MULTIPLE;
  PermissionRequestGestureType gesture_type =
      PermissionRequestGestureType::UNKNOWN;
  if (requests.size() == 1) {
    request_type = GetUmaValueForRequestType(requests[0]->request_type());
    gesture_type = requests[0]->GetGestureType();
  }

  if (accepted) {
    if (is_one_time) {
      PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptAcceptedOnce, request_type);
      PERMISSION_BUBBLE_GESTURE_TYPE_UMA(
          kPermissionsPromptAcceptedOnceGesture,
          kPermissionsPromptAcceptedOnceNoGesture, gesture_type, request_type);
    } else {
      PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptAccepted, request_type);
      PERMISSION_BUBBLE_GESTURE_TYPE_UMA(kPermissionsPromptAcceptedGesture,
                                         kPermissionsPromptAcceptedNoGesture,
                                         gesture_type, request_type);
    }
  } else {
    PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptDenied, request_type);
    PERMISSION_BUBBLE_GESTURE_TYPE_UMA(kPermissionsPromptDeniedGesture,
                                       kPermissionsPromptDeniedNoGesture,
                                       gesture_type, request_type);
  }
}

void PermissionUmaUtil::RecordTimeElapsedBetweenGrantAndUse(
    ContentSettingsType type,
    base::TimeDelta delta,
    content_settings::SettingSource source) {
  std::string base_histogram = "Permissions.Usage.ElapsedTimeSinceGrant." +
                               PermissionUtil::GetPermissionString(type);
  std::string source_suffix;
  switch (source) {
    case content_settings::SETTING_SOURCE_NONE:
      source_suffix = "FromNone";
      break;
    case content_settings::SETTING_SOURCE_POLICY:
      source_suffix = "FromPolicy";
      break;
    case content_settings::SETTING_SOURCE_EXTENSION:
      source_suffix = "FromExtension";
      break;
    case content_settings::SETTING_SOURCE_USER:
      source_suffix = "FromUser";
      break;
    case content_settings::SETTING_SOURCE_ALLOWLIST:
      source_suffix = "FromAllowlist";
      break;
    case content_settings::SETTING_SOURCE_SUPERVISED:
      source_suffix = "FromSupervised";
      break;
    case content_settings::SETTING_SOURCE_INSTALLED_WEBAPP:
      source_suffix = "FromInstalledWebApp";
      break;
    case content_settings::SETTING_SOURCE_TPCD_GRANT:
      source_suffix = "FromSourceTpcdGrant";
      break;
  }
  base::UmaHistogramCustomCounts(base_histogram, delta.InSeconds(), 1,
                                 base::Days(365).InSeconds(), 100);
  if (!source_suffix.empty()) {
    base::UmaHistogramCustomCounts(base_histogram + "." + source_suffix,
                                   delta.InSeconds(), 1,
                                   base::Days(365).InSeconds(), 100);
  }
}

void PermissionUmaUtil::RecordTimeElapsedBetweenGrantAndRevoke(
    ContentSettingsType type,
    base::TimeDelta delta) {
  base::UmaHistogramCustomCounts(
      "Permissions.Revocation.ElapsedTimeSinceGrant." +
          PermissionUtil::GetPermissionString(type),
      delta.InSeconds(), 1, base::Days(365).InSeconds(), 100);
}

// static
void PermissionUmaUtil::RecordAutoDSEPermissionReverted(
    ContentSettingsType permission_type,
    ContentSetting backed_up_setting,
    ContentSetting effective_setting,
    ContentSetting end_state_setting) {
  std::string permission_string =
      GetPermissionRequestString(GetUmaValueForRequestType(
          ContentSettingsTypeToRequestType(permission_type)));
  auto transition = GetAutoDSEPermissionRevertedTransition(
      backed_up_setting, effective_setting, end_state_setting);
  base::UmaHistogramEnumeration(
      "Permissions.DSE.AutoPermissionRevertTransition." + permission_string,
      transition);
}

// static
void PermissionUmaUtil::RecordDSEEffectiveSetting(
    ContentSettingsType permission_type,
    ContentSetting setting) {
  std::string permission_string =
      GetPermissionRequestString(GetUmaValueForRequestType(
          ContentSettingsTypeToRequestType(permission_type)));
  base::UmaHistogramEnumeration(
      "Permissions.DSE.EffectiveSetting." + permission_string, setting,
      CONTENT_SETTING_NUM_SETTINGS);
}

// static
void PermissionUmaUtil::RecordPermissionPredictionSource(
    PermissionPredictionSource prediction_source) {
  base::UmaHistogramEnumeration(
      "Permissions.PredictionService.PredictionSource", prediction_source);
}

// static
void PermissionUmaUtil::RecordPermissionPredictionServiceHoldback(
    RequestType request_type,
    bool is_on_device,
    bool is_heldback) {
  if (is_on_device) {
    base::UmaHistogramBoolean(
        "Permissions.OnDevicePredictionService.Response." +
            GetPermissionRequestString(GetUmaValueForRequestType(request_type)),
        is_heldback);
  } else {
    base::UmaHistogramBoolean(
        "Permissions.PredictionService.Response." +
            GetPermissionRequestString(GetUmaValueForRequestType(request_type)),
        is_heldback);
  }
}

// static
void PermissionUmaUtil::RecordPageInfoDialogAccessType(
    PageInfoDialogAccessType access_type) {
  base::UmaHistogramEnumeration(
      "Permissions.ConfirmationChip.PageInfoDialogAccessType", access_type);
}

// static
std::string PermissionUmaUtil::GetOneTimePermissionEventHistogram(
    ContentSettingsType type) {
  // `FILE_SYSTEM_WRITE_GUARD` is not part of `OneTimePermission`,
  // (i.e. `CanPermissionBeAllowedOnce()`), but it uses its background expiry
  // flow. As a result, allow logging for this event.
  DCHECK(permissions::PermissionUtil::CanPermissionBeAllowedOnce(type) ||
         type == ContentSettingsType::FILE_SYSTEM_WRITE_GUARD);

  std::string permission_type = GetPermissionRequestString(
      GetUmaValueForRequestType(ContentSettingsTypeToRequestType(type)));
  return "Permissions.OneTimePermission." + permission_type + ".Event";
}

// static
void PermissionUmaUtil::RecordOneTimePermissionEvent(
    ContentSettingsType type,
    OneTimePermissionEvent event) {
  base::UmaHistogramEnumeration(GetOneTimePermissionEventHistogram(type),
                                event);
}

// static
void PermissionUmaUtil::RecordPageInfoPermissionChangeWithin1m(
    ContentSettingsType type,
    PermissionAction previous_action,
    ContentSetting setting_after) {
  DCHECK(IsRequestablePermissionType(type));
  std::string permission_type = GetPermissionRequestString(
      GetUmaValueForRequestType(ContentSettingsTypeToRequestType(type)));
  std::string histogram_name =
      "Permissions.PageInfo.ChangedWithin1m." + permission_type;
  switch (previous_action) {
    case PermissionAction::GRANTED:
    case PermissionAction::GRANTED_ONCE:
      if (setting_after == ContentSetting::CONTENT_SETTING_BLOCK) {
        base::UmaHistogramEnumeration(histogram_name,
                                      PermissionChangeAction::REVOKED);
      } else if (setting_after == ContentSetting::CONTENT_SETTING_DEFAULT) {
        base::UmaHistogramEnumeration(
            histogram_name, PermissionChangeAction::RESET_FROM_ALLOWED);
      }
      break;
    case PermissionAction::DENIED:
      if (setting_after == ContentSetting::CONTENT_SETTING_ALLOW) {
        base::UmaHistogramEnumeration(histogram_name,
                                      PermissionChangeAction::REALLOWED);
      } else if (setting_after == ContentSetting::CONTENT_SETTING_DEFAULT) {
        base::UmaHistogramEnumeration(
            histogram_name, PermissionChangeAction::RESET_FROM_DENIED);
      }
      break;
    case PermissionAction::DISMISSED:  // dismissing had no effect on content
                                       // setting
    case PermissionAction::IGNORED:    // ignoring has no effect on content
                                       // settings
    case PermissionAction::REVOKED:  // not a relevant use case for this metric
    case PermissionAction::NUM:      // placeholder
      break;                         // NOP
  }
}

// static
void PermissionUmaUtil::RecordPageInfoPermissionChange(
    ContentSettingsType type,
    ContentSetting setting_before,
    ContentSetting setting_after,
    bool suppress_reload_page_bar) {
  DCHECK(IsRequestablePermissionType(type));
  // Currently only Camera and Mic are supported.
  DCHECK(type == ContentSettingsType::MEDIASTREAM_MIC ||
         type == ContentSettingsType::MEDIASTREAM_CAMERA);
  std::string permission_type = GetPermissionRequestString(
      GetUmaValueForRequestType(ContentSettingsTypeToRequestType(type)));
  std::string histogram_name =
      "Permissions.PageInfo.Changed." + permission_type;

  if (suppress_reload_page_bar) {
    histogram_name = histogram_name + ".ReloadInfobarNotShown";
  } else {
    histogram_name = histogram_name + ".ReloadInfobarShown";
  }

  if (setting_before == ContentSetting::CONTENT_SETTING_BLOCK) {
    if (setting_after == ContentSetting::CONTENT_SETTING_ALLOW) {
      base::UmaHistogramEnumeration(histogram_name,
                                    PermissionChangeAction::REALLOWED);
    } else if (setting_after == ContentSetting::CONTENT_SETTING_ASK ||
               setting_after == ContentSetting::CONTENT_SETTING_DEFAULT) {
      base::UmaHistogramEnumeration(histogram_name,
                                    PermissionChangeAction::RESET_FROM_DENIED);
    } else {
      NOTREACHED();
    }
  } else if (setting_before == ContentSetting::CONTENT_SETTING_ALLOW) {
    if (setting_after == ContentSetting::CONTENT_SETTING_BLOCK) {
      base::UmaHistogramEnumeration(histogram_name,
                                    PermissionChangeAction::REVOKED);
    } else if (setting_after == ContentSetting::CONTENT_SETTING_ASK ||
               setting_after == ContentSetting::CONTENT_SETTING_DEFAULT) {
      base::UmaHistogramEnumeration(histogram_name,
                                    PermissionChangeAction::RESET_FROM_ALLOWED);
    } else if (setting_after == ContentSetting::CONTENT_SETTING_ALLOW) {
      base::UmaHistogramEnumeration(
          histogram_name, PermissionChangeAction::REMEMBER_CHECKBOX_TOGGLED);
    } else {
      NOTREACHED();
    }
  }
}

// static
std::string PermissionUmaUtil::GetPermissionActionString(
    PermissionAction permission_action) {
  switch (permission_action) {
    case PermissionAction::GRANTED:
      return "Accepted";
    case PermissionAction::DENIED:
      return "Denied";
    case PermissionAction::DISMISSED:
      return "Dismissed";
    case PermissionAction::IGNORED:
      return "Ignored";
    case PermissionAction::GRANTED_ONCE:
      return "AcceptedOnce";
    default:
      NOTREACHED();
  }
  NOTREACHED();
  return std::string();
}

// static
std::string PermissionUmaUtil::GetPromptDispositionString(
    PermissionPromptDisposition ui_disposition) {
  switch (ui_disposition) {
    case PermissionPromptDisposition::ANCHORED_BUBBLE:
      return "AnchoredBubble";
    case PermissionPromptDisposition::CUSTOM_MODAL_DIALOG:
      return "CustomModalDialog";
    case PermissionPromptDisposition::ELEMENT_ANCHORED_BUBBLE:
      return "ElementAnchoredBubble";
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP:
      return "LocationBarLeftChip";
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_CHIP:
      return "LocationBarLeftQuietChip";
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_ABUSIVE_CHIP:
      return "LocationBarLeftQuietAbusiveChip";
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP_AUTO_BUBBLE:
      return "LocationBarLeftChipAutoBubble";
    case PermissionPromptDisposition::LOCATION_BAR_RIGHT_ANIMATED_ICON:
      return "LocationBarRightAnimatedIcon";
    case PermissionPromptDisposition::LOCATION_BAR_RIGHT_STATIC_ICON:
      return "LocationBarRightStaticIcon";
    case PermissionPromptDisposition::MINI_INFOBAR:
      return "MiniInfobar";
    case PermissionPromptDisposition::MESSAGE_UI:
      return "MessageUI";
    case PermissionPromptDisposition::MODAL_DIALOG:
      return "ModalDialog";
    case PermissionPromptDisposition::NONE_VISIBLE:
      return "NoneVisible";
    case PermissionPromptDisposition::NOT_APPLICABLE:
      return "NotApplicable";
    case PermissionPromptDisposition::MAC_OS_PROMPT:
      return "MacOsPrompt";
  }

  NOTREACHED();
  return std::string();
}

// static
std::string PermissionUmaUtil::GetPromptDispositionReasonString(
    PermissionPromptDispositionReason ui_disposition_reason) {
  switch (ui_disposition_reason) {
    case PermissionPromptDispositionReason::DEFAULT_FALLBACK:
      return "DefaultFallback";
    case PermissionPromptDispositionReason::ON_DEVICE_PREDICTION_MODEL:
      return "OnDevicePredictionModel";
    case PermissionPromptDispositionReason::PREDICTION_SERVICE:
      return "PredictionService";
    case PermissionPromptDispositionReason::SAFE_BROWSING_VERDICT:
      return "SafeBrowsingVerdict";
    case PermissionPromptDispositionReason::USER_PREFERENCE_IN_SETTINGS:
      return "UserPreferenceInSettings";
  }

  NOTREACHED();
  return std::string();
}

// static
std::string PermissionUmaUtil::GetRequestTypeString(RequestType request_type) {
  return GetPermissionRequestString(GetUmaValueForRequestType(request_type));
}

// static
bool PermissionUmaUtil::IsPromptDispositionQuiet(
    PermissionPromptDisposition prompt_disposition) {
  switch (prompt_disposition) {
    case PermissionPromptDisposition::LOCATION_BAR_RIGHT_STATIC_ICON:
    case PermissionPromptDisposition::LOCATION_BAR_RIGHT_ANIMATED_ICON:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_CHIP:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_ABUSIVE_CHIP:
    case PermissionPromptDisposition::MINI_INFOBAR:
    case PermissionPromptDisposition::MESSAGE_UI:
    case PermissionPromptDisposition::MAC_OS_PROMPT:
      return true;
    case PermissionPromptDisposition::ANCHORED_BUBBLE:
    case PermissionPromptDisposition::ELEMENT_ANCHORED_BUBBLE:
    case PermissionPromptDisposition::MODAL_DIALOG:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP_AUTO_BUBBLE:
    case PermissionPromptDisposition::NONE_VISIBLE:
    case PermissionPromptDisposition::CUSTOM_MODAL_DIALOG:
    case PermissionPromptDisposition::NOT_APPLICABLE:
      return false;
  }
}

// static
bool PermissionUmaUtil::IsPromptDispositionLoud(
    PermissionPromptDisposition prompt_disposition) {
  switch (prompt_disposition) {
    case PermissionPromptDisposition::ANCHORED_BUBBLE:
    case PermissionPromptDisposition::ELEMENT_ANCHORED_BUBBLE:
    case PermissionPromptDisposition::MODAL_DIALOG:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_CHIP_AUTO_BUBBLE:
      return true;
    case PermissionPromptDisposition::LOCATION_BAR_RIGHT_STATIC_ICON:
    case PermissionPromptDisposition::LOCATION_BAR_RIGHT_ANIMATED_ICON:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_CHIP:
    case PermissionPromptDisposition::LOCATION_BAR_LEFT_QUIET_ABUSIVE_CHIP:
    case PermissionPromptDisposition::MINI_INFOBAR:
    case PermissionPromptDisposition::MESSAGE_UI:
    case PermissionPromptDisposition::NONE_VISIBLE:
    case PermissionPromptDisposition::CUSTOM_MODAL_DIALOG:
    case PermissionPromptDisposition::NOT_APPLICABLE:
    case PermissionPromptDisposition::MAC_OS_PROMPT:
      return false;
  }
}

// static
void PermissionUmaUtil::RecordIgnoreReason(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    PermissionPromptDisposition prompt_disposition,
    PermissionIgnoredReason reason) {
  RequestTypeForUma request_type = RequestTypeForUma::MULTIPLE;
  if (requests.size() == 1) {
    request_type = GetUmaValueForRequestType(requests[0]->request_type());
  }

  std::string histogram_name =
      "Permissions.Prompt." + GetPermissionRequestString(request_type) + "." +
      GetPromptDispositionString(prompt_disposition) + ".IgnoredReason";
  base::UmaHistogramEnumeration(histogram_name, reason,
                                PermissionIgnoredReason::NUM);
}

// static
void PermissionUmaUtil::RecordPermissionsUsageSourceAndPolicyConfiguration(
    ContentSettingsType content_settings_type,
    content::RenderFrameHost* render_frame_host) {
  const bool is_cross_origin_subframe =
      IsCrossOriginSubframe(render_frame_host);
  const auto usage_histogram = base::StrCat(
      {kPermissionsExperimentalUsagePrefix,
       PermissionUtil::GetPermissionString(content_settings_type)});
  base::UmaHistogramBoolean(
      base::StrCat({usage_histogram, ".IsCrossOriginFrame"}),
      is_cross_origin_subframe);
  if (is_cross_origin_subframe) {
    RecordTopLevelPermissionsHeaderPolicy(
        content_settings_type,
        base::StrCat(
            {usage_histogram, ".CrossOriginFrame.TopLevelHeaderPolicy"}),
        render_frame_host);
  }
}

// static
void PermissionUmaUtil::RecordElementAnchoredBubbleDismiss(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    DismissedReason reason) {
  CHECK(!requests.empty());

  RequestTypeForUma type =
      GetUmaValueForRequestType(requests[0]->request_type());
  if (requests.size() > 1) {
    type = RequestTypeForUma::MULTIPLE;
  }

  base::UmaHistogramEnumeration("Permissions.Prompt." +
                                    GetPermissionRequestString(type) +
                                    ".ElementAnchoredBubble.DismissedReason",
                                reason);
}

// static
void PermissionUmaUtil::RecordElementAnchoredBubbleOsScreenAction(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    OsScreen screen,
    OsScreenAction action) {
  CHECK(!requests.empty());

  RequestTypeForUma type =
      GetUmaValueForRequestType(requests[0]->request_type());
  if (requests.size() > 1) {
    type = RequestTypeForUma::MULTIPLE;
  }

  std::string screen_type;
  switch (screen) {
    case OsScreen::OS_PROMPT:
      screen_type = "OS_PROMPT";
      break;
    case OsScreen::OS_SYSTEM_SETTINGS:
      screen_type = "OS_SYSTEM_SETTINGS";
      break;
    default:
      NOTREACHED();
  }

  base::UmaHistogramEnumeration(
      "Permissions.Prompt." + GetPermissionRequestString(type) +
          ".ElementAnchoredBubble" + screen_type + ".OsScreenAction",
      action);
}

void PermissionUmaUtil::RecordElementAnchoredBubbleVariantUMA(
    const std::vector<raw_ptr<PermissionRequest, VectorExperimental>>& requests,
    ElementAnchoredBubbleVariant variant) {
  CHECK(!requests.empty());

  RequestTypeForUma type =
      GetUmaValueForRequestType(requests[0]->request_type());
  if (requests.size() > 1) {
    type = RequestTypeForUma::MULTIPLE;
  }

  base::UmaHistogramEnumeration("Permissions.Prompt." +
                                    GetPermissionRequestString(type) +
                                    ".ElementAnchoredBubble.Variant",
                                variant);
}

// static
void PermissionUmaUtil::RecordCrossOriginFrameActionAndPolicyConfiguration(
    ContentSettingsType content_settings_type,
    PermissionAction action,
    content::RenderFrameHost* render_frame_host) {
  DCHECK(IsCrossOriginSubframe(render_frame_host));

  const auto histogram =
      base::StrCat({kPermissionsActionPrefix,
                    PermissionUtil::GetPermissionString(content_settings_type),
                    ".CrossOriginFrame"});
  base::UmaHistogramEnumeration(histogram, action, PermissionAction::NUM);
  RecordTopLevelPermissionsHeaderPolicy(
      content_settings_type, base::StrCat({histogram, ".TopLevelHeaderPolicy"}),
      render_frame_host);
}

// static
void PermissionUmaUtil::RecordTopLevelPermissionsHeaderPolicyOnNavigation(
    content::RenderFrameHost* render_frame_host) {
  DCHECK(render_frame_host);
  static constexpr ContentSettingsType kContentSettingsTypesForMetrics[] = {
      ContentSettingsType::GEOLOCATION, ContentSettingsType::MEDIASTREAM_CAMERA,
      ContentSettingsType::MEDIASTREAM_MIC};

  for (const auto content_settings_type : kContentSettingsTypesForMetrics) {
    const auto feature =
        PermissionUtil::GetPermissionsPolicyFeature(content_settings_type);
    DCHECK(feature.has_value());
    base::UmaHistogramEnumeration(
        base::StrCat(
            {"Permissions.Experimental.PrimaryMainNavigationFinished.",
             PermissionUtil::GetPermissionString(content_settings_type),
             ".TopLevelHeaderPolicy"}),
        GetTopLevelPermissionHeaderPolicyForUMA(render_frame_host,
                                                feature.value()),
        PermissionHeaderPolicyForUMA::NUM);
  }
}

void PermissionUmaUtil::RecordPermissionRegrantForUnusedSites(
    const GURL& origin,
    ContentSettingsType content_settings_type,
    PermissionSourceUI source_ui,
    content::BrowserContext* browser_context,
    base::Time current_time) {
  auto* hcsm = PermissionsClient::Get()->GetSettingsMap(browser_context);
  std::optional<uint32_t> days_since_revocation =
      GetDaysSinceUnusedSitePermissionRevocation(origin, content_settings_type,
                                                 current_time, hcsm);
  if (!days_since_revocation.has_value()) {
    return;
  }
  std::string source_ui_string;
  // We are only interested in permission updates through the UI that go from
  // Ask to Allow. This can only be done through the permission prompt and the
  // site settings page.
  switch (source_ui) {
    case PermissionSourceUI::PROMPT:
      source_ui_string = "Prompt";
      break;
    case PermissionSourceUI::SITE_SETTINGS:
      source_ui_string = "Settings";
      break;
    default:
      NOTREACHED();
  }
  base::UmaHistogramExactLinear(
      "Settings.SafetyCheck.UnusedSitePermissionsRegrantDays" +
          source_ui_string + "." +
          PermissionUtil::GetPermissionString(content_settings_type),
      days_since_revocation.value(), 31);
  base::UmaHistogramExactLinear(
      "Settings.SafetyCheck.UnusedSitePermissionsRegrantDays" +
          source_ui_string + ".All",
      days_since_revocation.value(), 31);
}

// static
std::optional<uint32_t>
PermissionUmaUtil::GetDaysSinceUnusedSitePermissionRevocation(
    const GURL& origin,
    ContentSettingsType content_settings_type,
    base::Time current_time,
    HostContentSettingsMap* hcsm) {
  content_settings::SettingInfo info;
  base::Value stored_value(hcsm->GetWebsiteSetting(
      origin, origin, ContentSettingsType::REVOKED_UNUSED_SITE_PERMISSIONS,
      &info));
  if (!stored_value.is_dict()) {
    return std::nullopt;
  }
  base::Value::List* permission_type_list =
      stored_value.GetDict().FindList(permissions::kRevokedKey);
  if (!permission_type_list) {
    return std::nullopt;
  }
  base::Time revoked_time =
      info.metadata.expiration() -
      content_settings::features::
          kSafetyCheckUnusedSitePermissionsRevocationCleanUpThreshold.Get();
  uint32_t days_since_revoked = (current_time - revoked_time).InDays();

  for (auto& permission_type : *permission_type_list) {
    auto type_int = permission_type.GetIfInt();
    if (!type_int.has_value()) {
      continue;
    }
    if (content_settings_type ==
        static_cast<ContentSettingsType>(type_int.value())) {
      return days_since_revoked;
    }
  }

  return std::nullopt;
}

}  // namespace permissions