chromeos/ash/components/scalable_iph/scalable_iph.cc - chromium/src - Git at Google

 // 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 "chromeos/ash/components/scalable_iph/scalable_iph.h"

 #include <memory>
 #include <string_view>
 #include <vector>

 #include "ash/constants/ash_features.h"
 #include "base/check.h"
 #include "base/check_is_test.h"
 #include "base/containers/fixed_flat_map.h"
 #include "base/containers/fixed_flat_set.h"
 #include "base/feature_list.h"
 #include "base/functional/bind.h"
 #include "base/location.h"
 #include "base/memory/raw_ptr.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/no_destructor.h"
 #include "base/notreached.h"
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chromeos/ash/components/scalable_iph/config.h"
 #include "chromeos/ash/components/scalable_iph/iph_session.h"
 #include "chromeos/ash/components/scalable_iph/logger.h"
 #include "chromeos/ash/components/scalable_iph/scalable_iph_constants.h"
 #include "chromeos/ash/components/scalable_iph/scalable_iph_delegate.h"
 #include "components/feature_engagement/public/feature_constants.h"

 namespace scalable_iph {

 namespace {

 using NotificationParams =
     ::scalable_iph::ScalableIphDelegate::NotificationParams;
 using BubbleParams = ::scalable_iph::ScalableIphDelegate::BubbleParams;
 using BubbleIcon = ::scalable_iph::ScalableIphDelegate::BubbleIcon;

 constexpr char kFunctionCallAfterKeyedServiceShutdown[] =
     "Function call after keyed service shutdown.";

 // A set of ScalableIph events which can trigger an IPH.
 constexpr auto kIphTriggeringEvents =
     base::MakeFixedFlatSet<ScalableIph::Event>(
         {ScalableIph::Event::kFiveMinTick, ScalableIph::Event::kUnlocked});

 bool force_enable_iph_feature_for_testing = false;

 std::string GetHelpAppIphEventName(ActionType action_type) {
   switch (action_type) {
     case ActionType::kOpenChrome:
       return kEventNameHelpAppActionTypeOpenChrome;
     case ActionType::kOpenLauncher:
       return kEventNameHelpAppActionTypeOpenLauncher;
     case ActionType::kOpenPersonalizationApp:
       return kEventNameHelpAppActionTypeOpenPersonalizationApp;
     case ActionType::kOpenPlayStore:
       return kEventNameHelpAppActionTypeOpenPlayStore;
     case ActionType::kOpenGoogleDocs:
       return kEventNameHelpAppActionTypeOpenGoogleDocs;
     case ActionType::kOpenGooglePhotos:
       return kEventNameHelpAppActionTypeOpenGooglePhotos;
     case ActionType::kOpenSettingsPrinter:
       return kEventNameHelpAppActionTypeOpenSettingsPrinter;
     case ActionType::kOpenPhoneHub:
       return kEventNameHelpAppActionTypeOpenPhoneHub;
     case ActionType::kOpenYouTube:
       return kEventNameHelpAppActionTypeOpenYouTube;
     case ActionType::kOpenFileManager:
       return kEventNameHelpAppActionTypeOpenFileManager;
     case ActionType::kInvalid:
     default:
       return "";
   }
 }

 // The list of IPH features `SclableIph` supports. `ScalableIph` checks trigger
 // conditions of all events listed in this list when it receives an `Event`.
 const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
 GetFeatureListConstant() {
   static const base::NoDestructor<
       std::vector<raw_ptr<const base::Feature, VectorExperimental>>>
       feature_list({
           // This must be sorted from One to Ten. A config expects that IPHs are
           // evaluated in this priority.
           // Timer based.
           &feature_engagement::kIPHScalableIphTimerBasedOneFeature,
           &feature_engagement::kIPHScalableIphTimerBasedTwoFeature,
           &feature_engagement::kIPHScalableIphTimerBasedThreeFeature,
           &feature_engagement::kIPHScalableIphTimerBasedFourFeature,
           &feature_engagement::kIPHScalableIphTimerBasedFiveFeature,
           &feature_engagement::kIPHScalableIphTimerBasedSixFeature,
           &feature_engagement::kIPHScalableIphTimerBasedSevenFeature,
           &feature_engagement::kIPHScalableIphTimerBasedEightFeature,
           &feature_engagement::kIPHScalableIphTimerBasedNineFeature,
           &feature_engagement::kIPHScalableIphTimerBasedTenFeature,
           // Unlocked based.
           &feature_engagement::kIPHScalableIphUnlockedBasedOneFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedTwoFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedThreeFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedFourFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedFiveFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedSixFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedSevenFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedEightFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedNineFeature,
           &feature_engagement::kIPHScalableIphUnlockedBasedTenFeature,
           // Help App based.
           &feature_engagement::kIPHScalableIphHelpAppBasedNudgeFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedOneFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedTwoFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedThreeFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedFourFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedFiveFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedSixFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedSevenFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedEightFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedNineFeature,
           &feature_engagement::kIPHScalableIphHelpAppBasedTenFeature,
           // Gaming.
           &feature_engagement::kIPHScalableIphGamingFeature,
       });
   return *feature_list;
 }

 const base::flat_map<std::string, ActionType>& GetActionTypesMap() {
   // Key will be set in server side config.
   static const base::NoDestructor<base::flat_map<std::string, ActionType>>
       action_types_map({
           {kActionTypeOpenChrome, ActionType::kOpenChrome},
           {kActionTypeOpenLauncher, ActionType::kOpenLauncher},
           {kActionTypeOpenPersonalizationApp,
            ActionType::kOpenPersonalizationApp},
           {kActionTypeOpenPlayStore, ActionType::kOpenPlayStore},
           {kActionTypeOpenGoogleDocs, ActionType::kOpenGoogleDocs},
           {kActionTypeOpenGooglePhotos, ActionType::kOpenGooglePhotos},
           {kActionTypeOpenSettingsPrinter, ActionType::kOpenSettingsPrinter},
           {kActionTypeOpenPhoneHub, ActionType::kOpenPhoneHub},
           {kActionTypeOpenYouTube, ActionType::kOpenYouTube},
           {kActionTypeOpenFileManager, ActionType::kOpenFileManager},
           {kActionTypeOpenHelpAppPerks, ActionType::kOpenHelpAppPerks},
           {kActionTypeOpenChromebookPerksWeb,
            ActionType::kOpenChromebookPerksWeb},
           {kActionTypeOpenChromebookPerksGfnPriority2022,
            ActionType::kOpenChromebookPerksGfnPriority2022},
           {kActionTypeOpenChromebookPerksMinecraft2023,
            ActionType::kOpenChromebookPerksMinecraft2023},
           {kActionTypeOpenChromebookPerksMinecraftRealms2023,
            ActionType::kOpenChromebookPerksMinecraftRealms2023},
       });
   return *action_types_map;
 }

 const base::flat_map<std::string, BubbleIcon>& GetBubbleIconsMap() {
   // Key will be set in server side config.
   static const base::NoDestructor<base::flat_map<std::string, BubbleIcon>>
       bubble_icons_map({
           {kBubbleIconChromeIcon, BubbleIcon::kChromeIcon},
           {kBubbleIconPlayStoreIcon, BubbleIcon::kPlayStoreIcon},
           {kBubbleIconGoogleDocsIcon, BubbleIcon::kGoogleDocsIcon},
           {kBubbleIconGooglePhotosIcon, BubbleIcon::kGooglePhotosIcon},
           {kBubbleIconPrintJobsIcon, BubbleIcon::kPrintJobsIcon},
           {kBubbleIconYouTubeIcon, BubbleIcon::kYouTubeIcon},
       });
   return *bubble_icons_map;
 }

 constexpr auto kAppListItemActivationEventsMap =
     base::MakeFixedFlatMap<std::string_view, ScalableIph::Event>({
         {kWebAppGoogleDocsAppId,
          ScalableIph::Event::kAppListItemActivationGoogleDocs},
         {kWebAppYouTubeAppId,
          ScalableIph::Event::kAppListItemActivationYouTube},
         {kWebAppGooglePhotosAppId,
          ScalableIph::Event::kAppListItemActivationGooglePhotosWeb},
         {kAndroidAppGooglePlayStoreAppId,
          ScalableIph::Event::kAppListItemActivationGooglePlayStore},
         {kAndroidAppGooglePhotosAppId,
          ScalableIph::Event::kAppListItemActivationGooglePhotosAndroid},
     });

 constexpr auto kShelfItemActivationEventsMap =
     base::MakeFixedFlatMap<std::string_view, ScalableIph::Event>({
         {kWebAppGoogleDocsAppId,
          ScalableIph::Event::kShelfItemActivationGoogleDocs},
         {kWebAppYouTubeAppId, ScalableIph::Event::kShelfItemActivationYouTube},
         {kWebAppGooglePhotosAppId,
          ScalableIph::Event::kShelfItemActivationGooglePhotosWeb},
         {kAndroidGooglePhotosAppId,
          ScalableIph::Event::kShelfItemActivationGooglePhotosAndroid},
     });

 constexpr base::TimeDelta kTimeTickEventInterval = base::Minutes(5);

 std::string GetEventName(ScalableIph::Event event) {
   // Use switch statement as you can get a compiler error if you forget to add a
   // conversion.
   switch (event) {
     case ScalableIph::Event::kFiveMinTick:
       return kEventNameFiveMinTick;
     case ScalableIph::Event::kUnlocked:
       return kEventNameUnlocked;
     case ScalableIph::Event::kAppListShown:
       return kEventNameAppListShown;
     case ScalableIph::Event::kAppListItemActivationYouTube:
       return kEventNameAppListItemActivationYouTube;
     case ScalableIph::Event::kAppListItemActivationGoogleDocs:
       return kEventNameAppListItemActivationGoogleDocs;
     case ScalableIph::Event::kAppListItemActivationGooglePhotosWeb:
       return kEventNameAppListItemActivationGooglePhotosWeb;
     case ScalableIph::Event::kOpenPersonalizationApp:
       return kEventNameOpenPersonalizationApp;
     case ScalableIph::Event::kShelfItemActivationYouTube:
       return kEventNameShelfItemActivationYouTube;
     case ScalableIph::Event::kShelfItemActivationGoogleDocs:
       return kEventNameShelfItemActivationGoogleDocs;
     case ScalableIph::Event::kShelfItemActivationGooglePhotosWeb:
       return kEventNameShelfItemActivationGooglePhotosWeb;
     case ScalableIph::Event::kShelfItemActivationGooglePhotosAndroid:
       return kEventNameShelfItemActivationGooglePhotosAndroid;
     case ScalableIph::Event::kShelfItemActivationGooglePlay:
       return kEventNameShelfItemActivationGooglePlay;
     case ScalableIph::Event::kAppListItemActivationGooglePlayStore:
       return kEventNameAppListItemActivationGooglePlayStore;
     case ScalableIph::Event::kAppListItemActivationGooglePhotosAndroid:
       return kEventNameAppListItemActivationGooglePhotosAndroid;
     case ScalableIph::Event::kPrintJobCreated:
       return kEventNamePrintJobCreated;
     case ScalableIph::Event::kGameWindowOpened:
       return kEventNameGameWindowOpened;
   }
 }

 std::string GetParamValue(const base::Feature& feature,
                           const std::string& param_name) {
   std::unique_ptr<Config> config = GetConfig(feature);
   if (config && config->params.contains(param_name)) {
     return config->params.at(param_name);
   }

   std::string fully_qualified_param_name =
       base::StrCat({feature.name, "_", param_name});
   std::string value = base::GetFieldTrialParamValueByFeature(
       feature, fully_qualified_param_name);

   // Non-fully-qualified name field must always be empty.
   DCHECK(base::GetFieldTrialParamValueByFeature(feature, param_name).empty())
       << param_name
       << " is specified in a non-fully-qualified way. It should be specified "
          "as "
       << fully_qualified_param_name
       << ". It's often the case in Scalable Iph to enable multiple features at "
          "once. To avoid an unexpected fall-back behavior, non-fully-qualified "
          "name is not accepted. Parameter names of custom fields must be "
          "specified in a fully qualified way: [Feature Name]_[Parameter Name]";

   return value;
 }

 void LogParamValueParseError(Logger* logger,
                              const base::Location& location,
                              const std::string& feature_name,
                              const std::string& param_name) {
   logger->Log(
       location,
       base::StringPrintf(
           "%s does not have a valid %s param value. Stop parsing the config.",
           feature_name.c_str(), param_name.c_str()));
 }

 UiType ParseUiType(Logger* logger, const base::Feature& feature) {
   std::string ui_type = GetParamValue(feature, kCustomUiTypeParamName);
   if (ui_type != kCustomUiTypeValueNotification &&
       ui_type != kCustomUiTypeValueBubble &&
       ui_type != kCustomUiTypeValueNone) {
     SCALABLE_IPH_LOG(logger) << ui_type << " is not a valid UI type.";
   }

   if (ui_type == kCustomUiTypeValueNotification) {
     return UiType::kNotification;
   }

   if (ui_type == kCustomUiTypeValueBubble) {
     return UiType::kBubble;
   }

   return UiType::kNone;
 }

 UiType GetUiType(Logger* logger, const base::Feature& feature) {
   std::unique_ptr<Config> config = GetConfig(feature);
   if (config) {
     return config->ui_type;
   }

   return ParseUiType(logger, feature);
 }

 ActionType ParseActionType(const std::string& action_type_string) {
   auto it = GetActionTypesMap().find(action_type_string);
   if (it == GetActionTypesMap().end()) {
     // If the server side config action type cannot be parsed, will return the
     // kInvalid as the parsed result.
     return ActionType::kInvalid;
   }

   return it->second;
 }

 std::string ParseActionEventName(const std::string& event_used_param) {
   // The `event_used_param` is in this format:
   // `name:ScalableIphTimerBasedOneEventUsed;comparator:any;window:365;storage:365`.
   auto key_values = base::SplitString(
       event_used_param, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (key_values.size() != 4) {
     return "";
   }
   auto name_value = base::SplitString(key_values[0], ":", base::TRIM_WHITESPACE,
                                       base::SPLIT_WANT_NONEMPTY);
   if (name_value.size() != 2) {
     return "";
   }

   if (name_value[0] != "name") {
     return "";
   }
   return name_value[1];
 }

 ScalableIphDelegate::NotificationIcon GetNotificationIcon(
     const std::string& icon) {
   if (icon == kCustomNotificationIconValueRedeem) {
     return ScalableIphDelegate::NotificationIcon::kRedeem;
   }

   return ScalableIphDelegate::NotificationIcon::kDefault;
 }

 ScalableIphDelegate::NotificationSummaryText GetNotificationSummaryText(
     const std::string& summary_text) {
   if (summary_text == kCustomNotificationSummaryTextValueNone) {
     return ScalableIphDelegate::NotificationSummaryText::kNone;
   }

   return ScalableIphDelegate::NotificationSummaryText::kWelcomeTips;
 }

 std::unique_ptr<NotificationParams> ParseNotificationParams(
     Logger* logger,
     const base::Feature& feature) {
   std::unique_ptr<NotificationParams> param =
       std::make_unique<NotificationParams>();
   param->notification_id =
       GetParamValue(feature, kCustomNotificationIdParamName);
   if (param->notification_id.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomNotificationIdParamName);
     return nullptr;
   }
   param->title = GetParamValue(feature, kCustomNotificationTitleParamName);
   if (param->title.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomNotificationTitleParamName);
     return nullptr;
   }

   // Notification body text is an optional field. This can take an empty string.
   param->text = GetParamValue(feature, kCustomNotificationBodyTextParamName);

   param->button.text =
       GetParamValue(feature, kCustomNotificationButtonTextParamName);
   if (param->button.text.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomNotificationButtonTextParamName);
     return nullptr;
   }
   std::string action_type =
       GetParamValue(feature, kCustomButtonActionTypeParamName);
   if (action_type.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomButtonActionTypeParamName);
     return nullptr;
   }
   param->button.action.action_type = ParseActionType(action_type);
   if (param->button.action.action_type == ActionType::kInvalid) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomButtonActionTypeParamName);
     return nullptr;
   }
   std::string event_used =
       GetParamValue(feature, kCustomButtonActionEventParamName);
   if (event_used.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomButtonActionEventParamName);
     return nullptr;
   }
   param->button.action.iph_event_name = ParseActionEventName(event_used);
   if (param->button.action.iph_event_name.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomButtonActionEventParamName);
     return nullptr;
   }

   std::string image_type =
       GetParamValue(feature, kCustomNotificationImageTypeParamName);
   param->image_type = ScalableIphDelegate::NotificationImageType::kNoImage;
   if (image_type == kCustomNotificationImageTypeValueWallpaper) {
     param->image_type = ScalableIphDelegate::NotificationImageType::kWallpaper;
   } else if (image_type == kCustomNotificationImageTypeValueMinecraft) {
     param->image_type = ScalableIphDelegate::NotificationImageType::kMinecraft;
   }

   std::string icon = GetParamValue(feature, kCustomNotificationIconParamName);
   if (!icon.empty()) {
     param->icon = GetNotificationIcon(icon);
   }
   SCALABLE_IPH_LOG(logger) << kCustomNotificationIconParamName
                            << " is specified as " << icon << ". " << param->icon
                            << " is set.";

   std::string summary_text =
       GetParamValue(feature, kCustomNotificationSummaryTextParamName);
   if (!summary_text.empty()) {
     param->summary_text = GetNotificationSummaryText(summary_text);
   }
   SCALABLE_IPH_LOG(logger) << kCustomNotificationSummaryTextParamName
                            << " is specified as " << summary_text << ". "
                            << param->summary_text << " is set.";

   std::string source =
       GetParamValue(feature, kCustomNotificationSourceTextParamName);
   if (!source.empty()) {
     param->source = source;
   } else {
     param->source = kCustomNotificationSourceTextValueDefault;
   }
   SCALABLE_IPH_LOG(logger) << kCustomNotificationSourceTextParamName
                            << " is specified as " << source << ". "
                            << param->source << " is set.";

   return param;
 }

 std::unique_ptr<NotificationParams> GetNotificationParams(
     Logger* logger,
     const base::Feature& feature) {
   std::unique_ptr<Config> config = GetConfig(feature);
   if (config) {
     return std::move(config->notification_params);
   }

   return ParseNotificationParams(logger, feature);
 }

 BubbleIcon ParseBubbleIcon(const std::string& icon_string) {
   auto it = GetBubbleIconsMap().find(icon_string);
   if (it == GetBubbleIconsMap().end()) {
     // If the server side config bubble icon cannot be parsed, will return the
     // kNoIcon as the parsed result.
     return BubbleIcon::kNoIcon;
   }
   return it->second;
 }

 std::unique_ptr<BubbleParams> ParseBubbleParams(Logger* logger,
                                                 const base::Feature& feature) {
   std::unique_ptr<BubbleParams> param = std::make_unique<BubbleParams>();
   param->bubble_id = GetParamValue(feature, kCustomBubbleIdParamName);
   if (param->bubble_id.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomBubbleIdParamName);
     return nullptr;
   }
   // Title of bubble could be empty.
   param->title = GetParamValue(feature, kCustomBubbleTitleParamName);
   param->text = GetParamValue(feature, kCustomBubbleTextParamName);
   if (param->text.empty()) {
     LogParamValueParseError(logger, FROM_HERE, feature.name,
                             kCustomBubbleTextParamName);
     return nullptr;
   }

   // Button and action:
   // Some nudge may not have a button and action.
   param->button.text = GetParamValue(feature, kCustomBubbleButtonTextParamName);
   if (!param->button.text.empty()) {
     std::string action_type =
         GetParamValue(feature, kCustomButtonActionTypeParamName);
     if (action_type.empty()) {
       LogParamValueParseError(logger, FROM_HERE, feature.name,
                               kCustomButtonActionTypeParamName);
       return nullptr;
     }

     param->button.action.action_type = ParseActionType(action_type);
     if (param->button.action.action_type == ActionType::kInvalid) {
       LogParamValueParseError(logger, FROM_HERE, feature.name,
                               kCustomButtonActionTypeParamName);
       return nullptr;
     }

     std::string event_used =
         GetParamValue(feature, kCustomButtonActionEventParamName);
     if (event_used.empty()) {
       LogParamValueParseError(logger, FROM_HERE, feature.name,
                               kCustomButtonActionEventParamName);
       return nullptr;
     }
     param->button.action.iph_event_name = ParseActionEventName(event_used);
     if (param->button.action.iph_event_name.empty()) {
       LogParamValueParseError(logger, FROM_HERE, feature.name,
                               kCustomButtonActionEventParamName);
       return nullptr;
     }
   }

   auto icon_string = GetParamValue(feature, kCustomBubbleIconParamName);
   param->icon = ParseBubbleIcon(icon_string);
   param->anchor_view_app_id =
       GetParamValue(feature, kCustomBubbleAnchorViewAppIdParamName);

   return param;
 }

 std::unique_ptr<BubbleParams> GetBubbleParams(Logger* logger,
                                               const base::Feature& feature) {
   std::unique_ptr<Config> config = GetConfig(feature);
   if (config) {
     return std::move(config->bubble_params);
   }

   return ParseBubbleParams(logger, feature);
 }

 bool ValidateVersionNumber(const base::Feature& feature) {
   std::unique_ptr<Config> config = GetConfig(feature);
   if (config) {
     return config->version_number == kCurrentVersionNumber;
   }

   std::string version_number_value =
       GetParamValue(feature, kCustomParamsVersionNumberParamName);
   if (version_number_value.empty()) {
     return false;
   }

   int version_number = 0;
   if (!base::StringToInt(version_number_value, &version_number)) {
     return false;
   }

   return version_number == kCurrentVersionNumber;
 }

 }  // namespace

 // static
 bool ScalableIph::IsAnyIphFeatureEnabled() {
   if (force_enable_iph_feature_for_testing) {
     return true;
   }

   const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
       feature_list = GetFeatureListConstant();
   for (auto feature : feature_list) {
     if (base::FeatureList::IsEnabled(*feature)) {
       return true;
     }
   }
   return false;
 }

 // static
 void ScalableIph::ForceEnableIphFeatureForTesting() {
   CHECK_IS_TEST();
   CHECK(!force_enable_iph_feature_for_testing)
       << "Iph feature is already force enabled";

   force_enable_iph_feature_for_testing = true;
 }

 ScalableIph::ScalableIph(feature_engagement::Tracker* tracker,
                          std::unique_ptr<ScalableIphDelegate> delegate,
                          std::unique_ptr<Logger> logger)
     : tracker_(tracker),
       delegate_(std::move(delegate)),
       logger_(std::move(logger)) {
   CHECK(tracker_);
   CHECK(delegate_);
   CHECK(logger_);

   delegate_observation_.Observe(delegate_.get());

   EnsureTimerStarted();

   online_ = delegate_->IsOnline();

   SCALABLE_IPH_LOG(GetLogger()) << "Initialize: Online: " << online_;

   tracker_->AddOnInitializedCallback(
       base::BindOnce(&ScalableIph::CheckTriggerConditionsOnInitSuccess,
                      weak_ptr_factory_.GetWeakPtr()));
 }

 ScalableIph::~ScalableIph() = default;

 void ScalableIph::Shutdown() {
   timer_.Stop();

   tracker_ = nullptr;

   delegate_observation_.Reset();
   delegate_.reset();
 }

 void ScalableIph::OnConnectionChanged(bool online) {
   if (online_ == online) {
     return;
   }

   online_ = online;

   SCALABLE_IPH_LOG(GetLogger())
       << "Connection status changed. Online: " << online;

   tracker_->AddOnInitializedCallback(
       base::BindOnce(&ScalableIph::CheckTriggerConditionsOnInitSuccess,
                      weak_ptr_factory_.GetWeakPtr()));
 }

 void ScalableIph::OnSessionStateChanged(
     ScalableIphDelegate::SessionState session_state) {
   if (session_state_ == session_state) {
     // Note that `OnSessionStateChanged` can be called more than once with the
     // same `session_state` as `session_manager::SessionState` does not map to
     // `ScalableIphDelegate::SessionState` with a 1:1 mapping, e.g.
     // `ScalableIphDelegate::SessionState::kOther` is mapped to several states
     // of `session_manager::SessionState`.
     return;
   }

   const bool unlocked =
       session_state_ == ScalableIphDelegate::SessionState::kLocked &&
       session_state != ScalableIphDelegate::SessionState::kLocked;

   session_state_ = session_state;

   SCALABLE_IPH_LOG(GetLogger())
       << "Session state changed to " << session_state
       << ". Whether this is considered to be an unlocked event or not: "
       << unlocked;

   if (unlocked) {
     RecordEvent(Event::kUnlocked);
   }

   if (session_state_ == ScalableIphDelegate::SessionState::kActive) {
     // Run conditions check as an IPH might be shown after a login.
     tracker_->AddOnInitializedCallback(
         base::BindOnce(&ScalableIph::CheckTriggerConditionsOnInitSuccess,
                        weak_ptr_factory_.GetWeakPtr()));
   }
 }

 void ScalableIph::OnSuspendDoneWithoutLockScreen() {
   if (session_state_ == ScalableIphDelegate::SessionState::kLocked) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Unexpected ScalableIph::OnSuspendDoneWithoutLockScreen call";
     DCHECK(false) << "OnSuspendDoneWithoutLockScreen should never be called "
                      "with a lock screen";
   }

   SCALABLE_IPH_LOG(GetLogger())
       << "Recording kUnlocked because of OnSuspendDoneWithoutLockScreen";
   RecordEvent(Event::kUnlocked);
 }

 void ScalableIph::OnAppListVisibilityChanged(bool shown) {
   SCALABLE_IPH_LOG(GetLogger())
       << "App list visibility changed. Shown: " << shown;

   if (shown) {
     RecordEvent(Event::kAppListShown);
   }
 }

 void ScalableIph::OnHasSavedPrintersChanged(bool has_saved_printers) {
   DCHECK_NE(has_saved_printers_, has_saved_printers);

   has_saved_printers_ = has_saved_printers;

   SCALABLE_IPH_LOG(GetLogger())
       << "Has saved printers status changed. Has saved printers: "
       << has_saved_printers;

   if (!has_saved_printers_closure_for_testing_.is_null()) {
     has_saved_printers_closure_for_testing_.Run();
     has_saved_printers_closure_for_testing_.Reset();
   }
 }

 void ScalableIph::OnPhoneHubOnboardingEligibleChanged(
     bool phonehub_onboarding_eligible) {
   DCHECK_NE(phonehub_onboarding_eligible_, phonehub_onboarding_eligible);

   SCALABLE_IPH_LOG(GetLogger())
       << "Phonehub onboarding eligible state has "
          "changed: Phone hub onboarding eligible: from: "
       << phonehub_onboarding_eligible_
       << " to: " << phonehub_onboarding_eligible;

   phonehub_onboarding_eligible_ = phonehub_onboarding_eligible;
 }

 void ScalableIph::PerformActionForIphSession(ActionType action_type) {
   SCALABLE_IPH_LOG(GetLogger())
       << "Performing an action for an iph session. Action type:" << action_type;
   PerformAction(action_type);
 }

 void ScalableIph::MaybeRecordAppListItemActivation(const std::string& id) {
   auto it = kAppListItemActivationEventsMap.find(id);
   if (it == kAppListItemActivationEventsMap.end()) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Observed an app list item activation. But not recording an app "
            "list item activation as it's not listed in the map.";
     return;
   }

   SCALABLE_IPH_LOG(GetLogger())
       << "Recording an app list item activation as event: " << it->second;
   // Record an event via `RecordEvent` instead of directly notifying an event to
   // `tracker_` as `RecordEvent` can do common tasks, e.g. Making sure that a
   // `tracker_` is initialized, etc.
   RecordEvent(it->second);
 }

 void ScalableIph::MaybeRecordShelfItemActivationById(const std::string& id) {
   auto it = kShelfItemActivationEventsMap.find(id);
   if (it == kShelfItemActivationEventsMap.end()) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Observed a shelf item activation. But not recording a shelf item "
            "activation as it's not listed in the map.";
     return;
   }

   SCALABLE_IPH_LOG(GetLogger())
       << "Recording a shelf item activation as event: " << it->second;
   RecordEvent(it->second);
 }

 void ScalableIph::OverrideFeatureListForTesting(
     const std::vector<raw_ptr<const base::Feature, VectorExperimental>>
         feature_list) {
   CHECK(feature_list_for_testing_.size() == 0)
       << "It's NOT allowed to override feature list twice for testing";
   CHECK(feature_list.size() > 0) << "An empty list is NOT allowed to set.";

   feature_list_for_testing_ = feature_list;
 }

 void ScalableIph::OverrideTaskRunnerForTesting(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   CHECK(timer_.IsRunning())
       << "Timer is expected to be always running until Shutdown";
   timer_.Stop();
   timer_.SetTaskRunner(task_runner);
   EnsureTimerStarted();
 }

 const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
 ScalableIph::GetFeatureListConstantForTesting() {
   CHECK_IS_TEST();
   return GetFeatureListConstant();
 }

 bool ScalableIph::ShouldPinHelpAppToShelf() {
   return ash::features::AreHelpAppWelcomeTipsEnabled();
 }

 void ScalableIph::PerformActionForHelpApp(ActionType action_type) {
   SCALABLE_IPH_LOG(GetLogger())
       << "Perform action for help app. Action type: " << action_type;

   std::string iph_event_name = GetHelpAppIphEventName(action_type);

   // ActionType enum is defined on the client side. We can use CHECK as this is
   // a client side constraint.
   CHECK(!iph_event_name.empty()) << "Unable to resolve the IPH event name to "
                                     "an action type for the help app";

   tracker_->NotifyEvent(iph_event_name);

   PerformAction(action_type);
 }

 void ScalableIph::PerformAction(ActionType action_type) {
   delegate_->PerformActionForScalableIph(action_type);
 }

 void ScalableIph::SetHasSavedPrintersChangedClosureForTesting(
     base::RepeatingClosure has_saved_printers_closure) {
   CHECK(has_saved_printers_closure_for_testing_.is_null());
   has_saved_printers_closure_for_testing_ =
       std::move(has_saved_printers_closure);
 }

 void ScalableIph::RecordEvent(ScalableIph::Event event) {
   SCALABLE_IPH_LOG(GetLogger()) << "Record event. Event: " << event;

   if (!tracker_) {
     DCHECK(false) << kFunctionCallAfterKeyedServiceShutdown;
     return;
   }

   // `AddOnInitializedCallback` immediately calls the callback if it's already
   // initialized.
   tracker_->AddOnInitializedCallback(
       base::BindOnce(&ScalableIph::RecordEventInternal,
                      weak_ptr_factory_.GetWeakPtr(), event));
 }

 Logger* ScalableIph::GetLogger() {
   return logger_.get();
 }

 void ScalableIph::EnsureTimerStarted() {
   timer_.Start(FROM_HERE, kTimeTickEventInterval,
                base::BindRepeating(&ScalableIph::RecordTimeTickEvent,
                                    weak_ptr_factory_.GetWeakPtr()));
 }

 void ScalableIph::RecordTimeTickEvent() {
   // Do not record timer event outside of an active session, e.g. OOBE, lock
   // screen.
   if (session_state_ != ScalableIphDelegate::SessionState::kActive) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Observed time tick event. But not recording it as session state is "
            "not Active. Current session state is: "
         << session_state_;
     return;
   }

   SCALABLE_IPH_LOG(GetLogger()) << "Record time tick event.";
   RecordEvent(Event::kFiveMinTick);
 }

 void ScalableIph::RecordEventInternal(ScalableIph::Event event,
                                       bool init_success) {
   if (!tracker_) {
     DCHECK(false) << kFunctionCallAfterKeyedServiceShutdown;
     return;
   }

   if (!init_success) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Failed to initialize feature_engagement::Tracker";
     DCHECK(false) << "Failed to initialize feature_engagement::Tracker.";
     return;
   }

   if (session_state_ != ScalableIphDelegate::SessionState::kActive) {
     SCALABLE_IPH_LOG(GetLogger())
         << "No event is expected to be recorded outside of an active session.";
     return;
   }

   const std::string event_name = GetEventName(event);
   SCALABLE_IPH_LOG(GetLogger()) << "Recording event as " << event_name;
   tracker_->NotifyEvent(event_name);

   if (kIphTriggeringEvents.contains(event)) {
     SCALABLE_IPH_LOG(GetLogger()) << event
                                   << " is a condition check triggering event. "
                                      "Running trigger conditions check.";
     CheckTriggerConditions(event);
   }
 }

 void ScalableIph::CheckTriggerConditionsOnInitSuccess(bool init_success) {
   if (!init_success) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Failed to initialize feature_engagement::Tracker.";
     return;
   }

   CheckTriggerConditions(std::nullopt);
 }

 void ScalableIph::CheckTriggerConditions(
     const std::optional<ScalableIph::Event>& trigger_event) {
   // Make sure that `tracker_` is initialized. `tracker_` should not cause crash
   // even if we call `ShouldTriggerHelpUI` before initialization. But it returns
   // false. It can become a difficult to notice/debug bug if we accidentally
   // introduce a code path where we call it before initialization.
   DCHECK(tracker_->IsInitialized());

   if (session_state_ != ScalableIphDelegate::SessionState::kActive) {
     SCALABLE_IPH_LOG(GetLogger()) << "Session state is not Active. No trigger "
                                      "condition check. Session state is "
                                   << session_state_;
     return;
   }

   SCALABLE_IPH_LOG(GetLogger()) << "Running trigger conditions check.";
   for (const base::Feature* feature : GetFeatureList()) {
     SCALABLE_IPH_LOG(GetLogger()) << "Checking: " << feature->name;

     if (!base::FeatureList::IsEnabled(*feature)) {
       SCALABLE_IPH_LOG(GetLogger())
           << feature->name << " is not enabled. Skipping condition check.";
       continue;
     }

     if (!ValidateVersionNumber(*feature)) {
       SCALABLE_IPH_LOG(GetLogger())
           << "Version number does not match with the current version "
              "number. Skipping a config: "
           << feature->name;
       continue;
     }

     if (!CheckCustomConditions(*feature, trigger_event)) {
       SCALABLE_IPH_LOG(GetLogger())
           << "Custom conditions are not satisfied for " << feature->name;
       continue;
     }
     SCALABLE_IPH_LOG(GetLogger())
         << "Custom conditions are satisfied for " << feature->name;

     if (!tracker_->ShouldTriggerHelpUI(*feature)) {
       SCALABLE_IPH_LOG(GetLogger())
           << "Trigger conditions in feature_engagement::Tracker are not "
              "satisfied for "
           << feature->name;
       continue;
     }
     SCALABLE_IPH_LOG(GetLogger())
         << "Trigger conditions in feature_engagement::Tracker are satisfied "
            "for "
         << feature->name;

     UiType ui_type = GetUiType(GetLogger(), *feature);
     switch (ui_type) {
       case UiType::kNotification: {
         std::unique_ptr<NotificationParams> notification_params =
             GetNotificationParams(GetLogger(), *feature);
         if (!notification_params) {
           SCALABLE_IPH_LOG(GetLogger())
               << "Failed to parse notification params for " << feature->name
               << ". Skipping the config.";
           continue;
         }
         SCALABLE_IPH_LOG(GetLogger()) << "Triggering a notification.";

         if (delegate_->ShowNotification(
                 *notification_params.get(),
                 std::make_unique<IphSession>(*feature, tracker_, this))) {
           SCALABLE_IPH_LOG(GetLogger())
               << "Requested the UI framework to show a notification. Request "
                  "status: success. -> Do not check other trigger conditions to "
                  "avoid triggering multiple IPHs at the same time.";
           return;
         }

         SCALABLE_IPH_LOG(GetLogger())
             << "Requested the UI framework to show a notification. Request "
                "status: failure. -> Keep checking other trigger conditions as "
                "this IPH should not be shown.";
         continue;
       }
       case UiType::kBubble: {
         std::unique_ptr<BubbleParams> bubble_params =
             GetBubbleParams(GetLogger(), *feature);
         if (!bubble_params) {
           SCALABLE_IPH_LOG(GetLogger())
               << "Failed to parse bubble params for " << feature->name
               << ". Skipping the config.";
           continue;
         }
         SCALABLE_IPH_LOG(GetLogger()) << "Triggering a bubble.";
         if (delegate_->ShowBubble(
                 *bubble_params.get(),
                 std::make_unique<IphSession>(*feature, tracker_, this))) {
           SCALABLE_IPH_LOG(GetLogger())
               << "Requested the UI framework to show a bubble. Request status: "
                  "success. -> Do not check other trigger conditions to avoid "
                  "triggering multiple IPHs at the same time.";
           return;
         }

         SCALABLE_IPH_LOG(GetLogger())
             << "Requested the UI framework to show a bubble. Request status: "
                "failure. -> Keep checking other trigger conditions as this IPH "
                "should not be shown.";
         continue;
       }
       case UiType::kNone:
         SCALABLE_IPH_LOG(GetLogger())
             << "Condition gets satisfied. But specified ui type is None.";
         break;
     }
   }
 }

 bool ScalableIph::CheckCustomConditions(
     const base::Feature& feature,
     const std::optional<ScalableIph::Event>& trigger_event) {
   SCALABLE_IPH_LOG(GetLogger())
       << "Checking custom conditions for " << feature.name;
   return CheckTriggerEvent(feature, trigger_event) &&
          CheckNetworkConnection(feature) && CheckClientAge(feature) &&
          CheckHasSavedPrinters(feature) &&
          CheckPhoneHubOnboardingEligible(feature);
 }

 bool ScalableIph::CheckTriggerEvent(
     const base::Feature& feature,
     const std::optional<ScalableIph::Event>& trigger_event) {
   if (!trigger_event.has_value()) {
     SCALABLE_IPH_LOG(GetLogger())
         << "This condition check is NOT triggered by an event. Skipping this "
            "trigger event condition check.";
     return true;
   }

   SCALABLE_IPH_LOG(GetLogger())
       << "Checking trigger event condition for " << feature.name;

   std::string trigger_event_condition =
       GetParamValue(feature, kCustomConditionTriggerEventParamName);
   if (trigger_event_condition.empty()) {
     SCALABLE_IPH_LOG(GetLogger()) << "No trigger event condition specified.";
     return true;
   }

   std::string trigger_event_name = GetEventName(trigger_event.value());

   const bool result = trigger_event_condition == trigger_event_name;
   SCALABLE_IPH_LOG(GetLogger())
       << "Specified trigger event name is " << trigger_event_condition
       << ". This condition check is triggered by " << trigger_event.value()
       << ". Compared trigger event name is " << trigger_event_name
       << ". Result: " << result;
   return result;
 }

 bool ScalableIph::CheckNetworkConnection(const base::Feature& feature) {
   SCALABLE_IPH_LOG(GetLogger())
       << "Checking network condition for " << feature.name;
   std::string connection_condition =
       GetParamValue(feature, kCustomConditionNetworkConnectionParamName);
   if (connection_condition.empty()) {
     SCALABLE_IPH_LOG(GetLogger()) << "No network condition specified.";
     return true;
   }

   // If an invalid value is provided, does not satisfy a condition for a
   // fail-safe behavior.
   if (connection_condition != kCustomConditionNetworkConnectionOnline) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Only " << kCustomConditionNetworkConnectionOnline
         << " is the valid value for network connection condition";
     return false;
   }

   SCALABLE_IPH_LOG(GetLogger())
       << "Expecting online. Current status is: Online: " << online_;
   return online_;
 }

 bool ScalableIph::CheckClientAge(const base::Feature& feature) {
   SCALABLE_IPH_LOG(GetLogger()) << "Checking client age for " << feature.name;
   std::string client_age_condition =
       GetParamValue(feature, kCustomConditionClientAgeInDaysParamName);
   if (client_age_condition.empty()) {
     SCALABLE_IPH_LOG(GetLogger()) << "No client age condition specified.";
     return true;
   }

   // Use `SCALABLE_IPH_LOG`s for logging instead of `DCHECK(false)` as we want
   // to test those fail-safe behaviors in browser_tests.
   int max_client_age = 0;
   if (!base::StringToInt(client_age_condition, &max_client_age)) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Failed to parse client age condition. It must be an integer.";
     return false;
   }

   if (max_client_age < 0) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Client age condition must be a positive integer value.";
     return false;
   }

   int client_age = delegate_->ClientAgeInDays();
   if (client_age < 0) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Client age is a negative number. This can happen if a "
            "user changes time zone, etc. Condition is not satisfied "
            "for a fail safe behavior.";
     return false;
   }

   const bool result = client_age <= max_client_age;
   SCALABLE_IPH_LOG(GetLogger())
       << "Current client age is " << client_age
       << ". Specified max client age is " << max_client_age
       << " (inclusive). Condition satisfied is: " << result;
   return result;
 }

 bool ScalableIph::CheckHasSavedPrinters(const base::Feature& feature) {
   SCALABLE_IPH_LOG(GetLogger())
       << "Checking has saved printers condition for " << feature.name;
   std::string has_saved_printers_condition =
       GetParamValue(feature, kCustomConditionHasSavedPrintersParamName);
   if (has_saved_printers_condition.empty()) {
     SCALABLE_IPH_LOG(GetLogger())
         << "No has saved printers condition specified.";
     return true;
   }

   if (has_saved_printers_condition !=
           kCustomConditionHasSavedPrintersValueTrue &&
       has_saved_printers_condition !=
           kCustomConditionHasSavedPrintersValueFalse) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Invalid value provided for "
         << kCustomConditionHasSavedPrintersParamName
         << ". This condition is not satisfied for a fail-safe behavior.";
     return false;
   }

   const bool expected_value =
       has_saved_printers_condition == kCustomConditionHasSavedPrintersValueTrue;
   const bool result = has_saved_printers_ == expected_value;
   SCALABLE_IPH_LOG(GetLogger())
       << "Expected value is " << expected_value
       << ". Current has saved printers value is " << has_saved_printers_
       << ". Result is " << result;
   return result;
 }

 bool ScalableIph::CheckPhoneHubOnboardingEligible(
     const base::Feature& feature) {
   SCALABLE_IPH_LOG(GetLogger())
       << "Checking phone hub onboarding eligible for " << feature.name;

   std::string phonehub_onboarding_eligible_value = GetParamValue(
       feature, kCustomConditionPhoneHubOnboardingEligibleParamName);
   if (phonehub_onboarding_eligible_value.empty()) {
     SCALABLE_IPH_LOG(GetLogger())
         << "No phone hub onboarding eligible condition specified.";
     return true;
   }

   if (phonehub_onboarding_eligible_value !=
       kCustomConditionPhoneHubOnboardingEligibleValueTrue) {
     SCALABLE_IPH_LOG(GetLogger())
         << "Only " << kCustomConditionPhoneHubOnboardingEligibleValueTrue
         << " is a valid value for "
         << kCustomConditionPhoneHubOnboardingEligibleParamName
         << ". Provided value: " << phonehub_onboarding_eligible_value
         << ". Condition not satisfied for a fail-safe behavior.";
     return false;
   }

   SCALABLE_IPH_LOG(GetLogger())
       << "Expected value is "
       << kCustomConditionPhoneHubOnboardingEligibleValueTrue
       << ". Current phone hub onboarding eligible value is "
       << phonehub_onboarding_eligible_ << ". Result is "
       << phonehub_onboarding_eligible_;
   return phonehub_onboarding_eligible_;
 }

 const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
 ScalableIph::GetFeatureList() const {
   if (!feature_list_for_testing_.empty()) {
     return feature_list_for_testing_;
   }

   return GetFeatureListConstant();
 }

 std::ostream& operator<<(std::ostream& out, ScalableIph::Event event) {
   return out << GetEventName(event);
 }

 }  // namespace scalable_iph