// Copyright 2023 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/compose/core/browser/compose_metrics.h"

#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/user_metrics.h"
#include "base/strings/strcat.h"
#include "base/time/time.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/metrics/public/cpp/ukm_source_id.h"

namespace compose {

const char kComposeDialogInnerTextShortenedBy[] =
    "Compose.Dialog.InnerTextShortenedBy";
const char kComposeDialogInnerTextSize[] = "Compose.Dialog.InnerTextSize";
const char kComposeDialogOpenLatency[] = "Compose.Dialog.OpenLatency";
const char kComposeDialogSelectionLength[] = "Compose.Dialog.SelectionLength";
const char kComposeRequestReason[] = "Compose.Request.Reason";
const char kComposeRequestDurationOkSuffix[] = ".Request.Duration.Ok";
const char kComposeRequestDurationErrorSuffix[] = ".Request.Duration.Error";
const char kComposeRequestStatus[] = "Compose.Request.Status";
const char kComposeSessionComposeCount[] = "Compose.Session.ComposeCount";
const char kComposeSessionCloseReason[] = "Compose.Session.CloseReason";
const char kComposeSessionDialogShownCount[] =
    "Compose.Session.DialogShownCount";
const char kComposeSessionEventCounts[] = "Compose.Session.EventCounts";
const char kComposeSessionDuration[] = "Compose.Session.Duration";
const char kComposeSessionOverOneDay[] = "Compose.Session.Duration.OverOneDay";
const char kComposeSessionUndoCount[] = "Compose.Session.UndoCount";
const char kComposeSessionUpdateInputCount[] =
    "Compose.Session.SubmitEditCount";
const char kComposeShowStatus[] = "Compose.ContextMenu.ShowStatus";
const char kComposeMSBBSessionCloseReason[] =
    "Compose.Session.FRE.MSBB.CloseReason";
const char kComposeMSBBSessionDialogShownCount[] =
    "Compose.Session.FRE.MSBB.DialogShownCount";
const char kComposeFirstRunSessionCloseReason[] =
    "Compose.Session.FRE.Disclaimer.CloseReason";
const char kComposeFirstRunSessionDialogShownCount[] =
    "Compose.Session.FRE.Disclaimer.DialogShownCount";
const char kInnerTextNodeOffsetFound[] =
    "Compose.Dialog.InnerTextNodeOffsetFound";
const char kComposeContextMenuCtr[] = "Compose.ContextMenu.CTR";
const char kComposeProactiveNudgeCtr[] = "Compose.ProactiveNudge.CTR";
const char kComposeSelectionNudgeCtr[] = "Compose.SelectionNudge.CTR";
const char kComposeProactiveNudgeShowStatus[] =
    "Compose.ProactiveNudge.ShowStatus";
const char kOpenComposeDialogResult[] =
    "Compose.ContextMenu.OpenComposeDialogResult";
const char kComposeSelectAll[] = "Compose.ContextMenu.SelectedAll";
const char kComposeStartSessionEntryPoint[] = "Compose.EntryPoint.SessionStart";
const char kComposeResumeSessionEntryPoint[] =
    "Compose.EntryPoint.SessionResume";

namespace {

std::string_view EvalLocationString(EvalLocation location) {
  switch (location) {
    case compose::EvalLocation::kServer:
      return "Server";
    case EvalLocation::kOnDevice:
      return "OnDevice";
  }
}

std::string_view LanguageSupportedString(bool page_language_supported) {
  return page_language_supported ? "PageLanguageSupported"
                                 : "PageLanguageUnsupported";
}

bool HasAckedFreOrAcceptedMsbb(ComposeFreOrMsbbSessionCloseReason reason) {
  switch (reason) {
    case ComposeFreOrMsbbSessionCloseReason::kAckedOrAcceptedWithoutInsert:
    case ComposeFreOrMsbbSessionCloseReason::kAckedOrAcceptedWithInsert:
      return true;
    case ComposeFreOrMsbbSessionCloseReason::kCloseButtonPressed:
    case ComposeFreOrMsbbSessionCloseReason::kAbandoned:
    case ComposeFreOrMsbbSessionCloseReason::kReplacedWithNewSession:
    case ComposeFreOrMsbbSessionCloseReason::kExceededMaxDuration:
      return false;
  }
}

}  // namespace

PageUkmTracker::PageUkmTracker(ukm::SourceId source_id)
    : source_id(source_id) {}

PageUkmTracker::~PageUkmTracker() {
  MaybeLogUkm();
}

void PageUkmTracker::MenuItemShown() {
  event_was_recorded_ = true;
  ++menu_item_shown_count_;
}

void PageUkmTracker::MenuItemClicked() {
  event_was_recorded_ = true;
  ++menu_item_clicked_count_;
}

void PageUkmTracker::ComposeTextInserted() {
  event_was_recorded_ = true;
  ++compose_text_inserted_count_;
}

void PageUkmTracker::ComposeProactiveNudgeShouldShow() {
  event_was_recorded_ = true;
  ++proactive_nudge_should_show_count_;
}

void PageUkmTracker::ProactiveNudgeShown() {
  event_was_recorded_ = true;
  ++proactive_nudge_shown_count_;
}

void PageUkmTracker::ProactiveNudgeOpened() {
  event_was_recorded_ = true;
  ++proactive_nudge_opened_count_;
}

void PageUkmTracker::ProactiveNudgeDisabledGlobally() {
  event_was_recorded_ = true;
  proactive_nudge_disabled_globally_ = true;
}

void PageUkmTracker::ProactiveNudgeDisabledForSite() {
  event_was_recorded_ = true;
  proactive_nudge_disabled_for_site_ = true;
}

void PageUkmTracker::ShowDialogAbortedDueToMissingFormData() {
  event_was_recorded_ = true;
  ++missing_form_data_count_;
}

void PageUkmTracker::ShowDialogAbortedDueToMissingFormFieldData() {
  event_was_recorded_ = true;
  ++missing_form_field_data_count_;
}

void PageUkmTracker::MaybeLogUkm() {
  if (!event_was_recorded_) {
    return;
  }

  ukm::builders::Compose_PageEvents(source_id)
      .SetMenuItemShown(
          ukm::GetExponentialBucketMinForCounts1000(menu_item_shown_count_))
      .SetMenuItemClicked(
          ukm::GetExponentialBucketMinForCounts1000(menu_item_clicked_count_))
      .SetComposeTextInserted(ukm::GetExponentialBucketMinForCounts1000(
          compose_text_inserted_count_))
      .SetProactiveNudgeShouldShow(ukm::GetExponentialBucketMinForCounts1000(
          proactive_nudge_should_show_count_))
      .SetProactiveNudgeShown(ukm::GetExponentialBucketMinForCounts1000(
          proactive_nudge_shown_count_))
      .SetProactiveNudgeOpened(ukm::GetExponentialBucketMinForCounts1000(
          proactive_nudge_opened_count_))
      .SetProactiveNudgeDisabledGlobally(proactive_nudge_disabled_globally_)
      .SetProactiveNudgeDisabledForSite(proactive_nudge_disabled_for_site_)
      .SetMissingFormData(
          ukm::GetExponentialBucketMinForCounts1000(missing_form_data_count_))
      .SetMissingFormFieldData(ukm::GetExponentialBucketMinForCounts1000(
          missing_form_field_data_count_))
      .Record(ukm::UkmRecorder::Get());
}

ComposeSessionEvents::ComposeSessionEvents() = default;

void LogComposeContextMenuCtr(ComposeContextMenuCtrEvent event) {
  base::UmaHistogramEnumeration(kComposeContextMenuCtr, event);
}

void LogComposeContextMenuShowStatus(ComposeShowStatus status) {
  base::UmaHistogramEnumeration(kComposeShowStatus, status);
}

void LogComposeProactiveNudgeCtr(ComposeNudgeCtrEvent event) {
  base::UmaHistogramEnumeration(kComposeProactiveNudgeCtr, event);
}

void LogComposeSelectionNudgeCtr(ComposeNudgeCtrEvent event) {
  base::UmaHistogramEnumeration(kComposeSelectionNudgeCtr, event);
}

void LogComposeProactiveNudgeShowStatus(ComposeShowStatus status) {
  base::UmaHistogramEnumeration(kComposeProactiveNudgeShowStatus, status);
}

void LogOpenComposeDialogResult(OpenComposeDialogResult result) {
  base::UmaHistogramEnumeration(kOpenComposeDialogResult, result);
}

void LogStartSessionEntryPoint(ComposeEntryPoint entry_point) {
  base::UmaHistogramEnumeration(kComposeStartSessionEntryPoint, entry_point);

  switch (entry_point) {
    case ComposeEntryPoint::kContextMenu:
      base::RecordAction(
          base::UserMetricsAction("Compose.StartedSession.ContextMenu"));
      break;
    case ComposeEntryPoint::kProactiveNudge:
      base::RecordAction(
          base::UserMetricsAction("Compose.StartedSession.ProactiveNudge"));
      break;
    case ComposeEntryPoint::kSelectionNudge:
      base::RecordAction(
          base::UserMetricsAction("Compose.StartedSession.SelectionNudge"));
      break;
    case ComposeEntryPoint::kSavedStateNudge:
    case ComposeEntryPoint::kSavedStateNotification:
      break;
  }
}

void LogResumeSessionEntryPoint(ComposeEntryPoint entry_point) {
  base::UmaHistogramEnumeration(kComposeResumeSessionEntryPoint, entry_point);
}

void LogComposeRequestReason(ComposeRequestReason reason) {
  base::UmaHistogramEnumeration(kComposeRequestReason, reason);
}

void LogComposeRequestReason(EvalLocation eval_location,
                             ComposeRequestReason reason) {
  base::UmaHistogramEnumeration(
      base::StrCat(
          {"Compose.", EvalLocationString(eval_location), ".Request.Reason"}),
      reason);
}

void LogComposeRequestStatus(bool page_language_supported,
                             compose::mojom::ComposeStatus status) {
  base::UmaHistogramEnumeration(kComposeRequestStatus, status);
  base::UmaHistogramEnumeration(
      base::StrCat({"Compose.Request.",
                    LanguageSupportedString(page_language_supported),
                    ".Status"}),
      status);
}

void LogComposeRequestStatus(EvalLocation eval_location,
                             bool page_language_supported,
                             compose::mojom::ComposeStatus status) {
  base::UmaHistogramEnumeration(
      base::StrCat(
          {"Compose.", EvalLocationString(eval_location), ".Request.Status"}),
      status);
  base::UmaHistogramEnumeration(
      base::StrCat({"Compose.", EvalLocationString(eval_location), ".Request.",
                    LanguageSupportedString(page_language_supported),
                    ".Status"}),
      status);
}

void LogComposeRequestDuration(base::TimeDelta duration,
                               EvalLocation eval_location,
                               bool is_ok) {
  std::string_view suffix =
      is_ok ? std::string_view(kComposeRequestDurationOkSuffix)
            : std::string_view(kComposeRequestDurationErrorSuffix);
  base::UmaHistogramMediumTimes(base::StrCat({"Compose", suffix}), duration);
  base::UmaHistogramMediumTimes(
      base::StrCat({"Compose.", EvalLocationString(eval_location), suffix}),
      duration);
}

void LogComposeSessionCloseReason(ComposeSessionCloseReason reason) {
  base::UmaHistogramEnumeration(kComposeSessionCloseReason, reason);
}

void LogComposeFirstRunSessionCloseReason(
    ComposeFreOrMsbbSessionCloseReason reason) {
  base::UmaHistogramEnumeration(kComposeFirstRunSessionCloseReason, reason);
}

void LogComposeFirstRunSessionDialogShownCount(
    ComposeFreOrMsbbSessionCloseReason reason,
    int dialog_shown_count) {
  std::string histogram_name = base::StrCat(
      {kComposeFirstRunSessionDialogShownCount,
       HasAckedFreOrAcceptedMsbb(reason) ? ".Acknowledged" : ".Ignored"});
  base::UmaHistogramCounts1000(histogram_name, dialog_shown_count);
}

void LogComposeMSBBSessionCloseReason(
    ComposeFreOrMsbbSessionCloseReason reason) {
  base::UmaHistogramEnumeration(kComposeMSBBSessionCloseReason, reason);
}

void LogComposeMSBBSessionDialogShownCount(
    ComposeFreOrMsbbSessionCloseReason reason,
    int dialog_shown_count) {
  std::string histogram_name = base::StrCat(
      {kComposeMSBBSessionDialogShownCount,
       HasAckedFreOrAcceptedMsbb(reason) ? ".Accepted" : ".Ignored"});
  base::UmaHistogramCounts1000(histogram_name, dialog_shown_count);
}

SessionEvalLocation GetSessionEvalLocationFromEvents(
    const ComposeSessionEvents& session_events) {
  if (session_events.server_responses == 0 &&
      session_events.on_device_responses == 0) {
    return SessionEvalLocation::kNone;
  } else if (session_events.server_responses > 0 &&
             session_events.on_device_responses > 0) {
    return SessionEvalLocation::kMixed;
  } else if (session_events.server_responses > 0) {
    return SessionEvalLocation::kServer;
  } else {
    return SessionEvalLocation::kOnDevice;
  }
}

std::optional<EvalLocation> GetEvalLocationFromEvents(
    const ComposeSessionEvents& session_events) {
  switch (GetSessionEvalLocationFromEvents(session_events)) {
    case SessionEvalLocation::kNone:
    case SessionEvalLocation::kMixed:
      return std::nullopt;
    case SessionEvalLocation::kServer:
      return EvalLocation::kServer;
    case SessionEvalLocation::kOnDevice:
      return EvalLocation::kOnDevice;
  }
}

void LogComposeSessionCloseMetrics(ComposeSessionCloseReason reason,
                                   const ComposeSessionEvents& session_events) {
  std::string status;
  switch (reason) {
    case ComposeSessionCloseReason::kInsertedResponse:
      status = ".Accepted";
      break;
    case ComposeSessionCloseReason::kCloseButtonPressed:
    case ComposeSessionCloseReason::kAbandoned:
    case ComposeSessionCloseReason::kReplacedWithNewSession:
    case ComposeSessionCloseReason::kCanceledBeforeResponseReceived:
    case compose::ComposeSessionCloseReason::kExceededMaxDuration:
      status = ".Ignored";
      break;
    case compose::ComposeSessionCloseReason::kEndedAtFre:
    case compose::ComposeSessionCloseReason::kAckedFreEndedAtMsbb:
    case compose::ComposeSessionCloseReason::kEndedAtMsbb:
      NOTREACHED();
  }

  // Report all location-agnostic metrics.
  LogComposeSessionCloseReason(reason);
  base::UmaHistogramCounts1000(kComposeSessionComposeCount + status,
                               session_events.compose_requests_count);
  base::UmaHistogramCounts1000(kComposeSessionDialogShownCount + status,
                               session_events.compose_prompt_view_count);
  base::UmaHistogramCounts1000(kComposeSessionUndoCount + status,
                               session_events.undo_count);
  base::UmaHistogramCounts1000(kComposeSessionUpdateInputCount + status,
                               session_events.update_input_count);
  LogComposeSessionEventCounts(std::nullopt, session_events);

  // Report all eval location specific metrics.
  SessionEvalLocation session_eval_location =
      GetSessionEvalLocationFromEvents(session_events);
  std::optional<EvalLocation> eval_location =
      GetEvalLocationFromEvents(session_events);
  base::UmaHistogramEnumeration("Compose.Session.EvalLocation",
                                session_eval_location);
  if (eval_location) {
    base::UmaHistogramEnumeration(
        base::StrCat({"Compose.", EvalLocationString(*eval_location),
                      ".Session.CloseReason"}),
        reason);
    base::UmaHistogramCounts1000(
        base::StrCat({"Compose.", EvalLocationString(*eval_location),
                      ".Session.ComposeCount", status}),
        session_events.compose_requests_count);
    base::UmaHistogramCounts1000(
        base::StrCat({"Compose.", EvalLocationString(*eval_location),
                      ".Session.DialogShownCount", status}),
        session_events.compose_prompt_view_count);
    base::UmaHistogramCounts1000(
        base::StrCat({"Compose.", EvalLocationString(*eval_location),
                      ".Session.UndoCount", status}),
        session_events.undo_count);
    base::UmaHistogramCounts1000(
        base::StrCat({"Compose.", EvalLocationString(*eval_location),
                      ".Session.SubmitEditCount", status}),
        session_events.update_input_count);
    LogComposeSessionEventCounts(eval_location, session_events);
  }
}

void LogComposeSessionCloseUkmMetrics(
    ukm::SourceId source_id,
    const ComposeSessionEvents& session_events) {
  // Log the UKM metrics for this session.
  ukm::builders::Compose_SessionProgress(source_id)
      .SetDialogShownCount(ukm::GetExponentialBucketMinForCounts1000(
          session_events.compose_prompt_view_count))
      .SetComposeCount(ukm::GetExponentialBucketMinForCounts1000(
          session_events.compose_requests_count))
      .SetShortenCount(session_events.shorten_count)
      .SetLengthenCount(ukm::GetExponentialBucketMinForCounts1000(
          session_events.lengthen_count))
      .SetFormalCount(ukm::GetExponentialBucketMinForCounts1000(
          session_events.formal_count))
      .SetCasualCount(ukm::GetExponentialBucketMinForCounts1000(
          session_events.casual_count))
      .SetRegenerateCount(ukm::GetExponentialBucketMinForCounts1000(
          session_events.regenerate_count))
      .SetUndoCount(
          ukm::GetExponentialBucketMinForCounts1000(session_events.undo_count))
      .SetInsertedResults(session_events.inserted_results)
      .SetCanceled(session_events.close_clicked)
      .SetStartedWithProactiveNudge(session_events.started_with_proactive_nudge)
      .Record(ukm::UkmRecorder::Get());
}

void LogComposeDialogInnerTextShortenedBy(int shortened_by) {
  base::UmaHistogramCounts10M(kComposeDialogInnerTextShortenedBy, shortened_by);
}

void LogComposeDialogInnerTextSize(int size) {
  base::UmaHistogramCounts10M(kComposeDialogInnerTextSize, size);
}

void LogComposeDialogInnerTextOffsetFound(bool inner_offset_found) {
  UMA_HISTOGRAM_ENUMERATION(kInnerTextNodeOffsetFound,
                            inner_offset_found
                                ? ComposeInnerTextNodeOffset::kOffsetFound
                                : ComposeInnerTextNodeOffset::kNoOffsetFound);
}

void LogComposeDialogOpenLatency(base::TimeDelta duration) {
  base::UmaHistogramMediumTimes(kComposeDialogOpenLatency, duration);
}

void LogComposeDialogSelectionLength(int length) {
  // The autofill::kMaxSelectedTextLength is in UTF16 bytes so divide by 2 for
  // the maximum number of unicode code points.
  const int max_selection_size = 51200 / 2;
  base::UmaHistogramCustomCounts(kComposeDialogSelectionLength, length, 1,
                                 max_selection_size + 1, 100);
}

void LogComposeSessionDuration(base::TimeDelta session_duration,
                               std::string session_suffix,
                               std::optional<EvalLocation> eval_location) {
  base::UmaHistogramLongTimes100(kComposeSessionDuration + session_suffix,
                                 session_duration);
  if (eval_location) {
    base::UmaHistogramLongTimes100(
        base::StrCat({"Compose.", EvalLocationString(*eval_location),
                      ".Session.Duration", session_suffix}),
        session_duration);
  }

  if (session_duration.InDays() > 1) {
    base::UmaHistogramBoolean(kComposeSessionOverOneDay, true);
  } else {
    base::UmaHistogramBoolean(kComposeSessionOverOneDay, false);
  }
}

void LogComposeRequestFeedback(EvalLocation eval_location,
                               ComposeRequestFeedback feedback) {
  base::UmaHistogramEnumeration(
      base::StrCat(
          {"Compose.", EvalLocationString(eval_location), ".Request.Feedback"}),
      feedback);
}

void LogComposeSelectAllStatus(ComposeSelectAllStatus select_all_status) {
  base::UmaHistogramEnumeration(kComposeSelectAll, select_all_status);
}

void LogComposeSessionEventCounts(std::optional<EvalLocation> eval_location,
                                  const ComposeSessionEvents& session_events) {
  std::string histogram;
  if (!eval_location) {
    histogram = kComposeSessionEventCounts;
  } else {
    histogram = base::StrCat({"Compose.", EvalLocationString(*eval_location),
                              ".Session.EventCounts"});
  }
  if (session_events.compose_dialog_open_count > 0) {
    base::UmaHistogramEnumeration(
        histogram, ComposeSessionEventTypes::kComposeDialogOpened);
  }
  if (session_events.compose_prompt_view_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kMainDialogShown);
  }
  if (session_events.successful_requests_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kSuccessfulRequest);
  }
  if (session_events.failed_requests_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kFailedRequest);
  }
  if (session_events.fre_view_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kFREShown);
  }
  if (session_events.fre_completed_in_session) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kFREAccepted);
  }
  if (session_events.msbb_view_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kMSBBShown);
  }
  if (session_events.msbb_settings_opened) {
    base::UmaHistogramEnumeration(
        histogram, ComposeSessionEventTypes::kMSBBSettingsOpened);
  }
  if (session_events.msbb_enabled_in_session) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kMSBBEnabled);
  }
  if (session_events.has_initial_text) {
    base::UmaHistogramEnumeration(
        histogram, ComposeSessionEventTypes::kStartedWithSelection);
  }
  if (session_events.compose_requests_count > 0) {
    // The first Compose event has to be "Create".
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kCreateClicked);
  }
  if (session_events.update_input_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kUpdateClicked);
  }
  if (session_events.regenerate_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kRetryClicked);
  }
  if (session_events.undo_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kUndoClicked);
  }
  if (session_events.redo_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kRedoClicked);
  }
  if (session_events.result_edit_count > 0) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kResultEdited);
  }
  bool has_used_modifier = false;
  if (session_events.shorten_count > 0) {
    has_used_modifier = true;
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kShortenClicked);
  }
  if (session_events.lengthen_count > 0) {
    has_used_modifier = true;
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kElaborateClicked);
  }
  if (session_events.casual_count > 0) {
    has_used_modifier = true;
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kCasualClicked);
  }
  if (session_events.formal_count > 0) {
    has_used_modifier = true;
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kFormalClicked);
  }
  if (has_used_modifier) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kAnyModifierUsed);
  }
  if (session_events.has_thumbs_down) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kThumbsDown);
  }
  if (session_events.has_thumbs_up) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kThumbsUp);
  }
  if (session_events.inserted_results) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kInsertClicked);
  }
  if (session_events.edited_result_inserted) {
    base::UmaHistogramEnumeration(
        histogram, ComposeSessionEventTypes::kEditedResultInserted);
  }
  if (session_events.close_clicked) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kCloseClicked);
  }
  if (session_events.did_click_edit) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kEditClicked);
  }
  if (session_events.did_click_cancel_on_edit) {
    base::UmaHistogramEnumeration(histogram,
                                  ComposeSessionEventTypes::kCancelEditClicked);
  }
}
}  // namespace compose