components/user_education/webui/whats_new_registry.cc - chromium/src.git - Git at Google

 // Copyright 2024 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/user_education/webui/whats_new_registry.h"

 #include "base/containers/contains.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/values.h"
 #include "ui/webui/resources/js/browser_command/browser_command.mojom.h"

 namespace whats_new {
 namespace {
 constexpr int kRequestEntropyLimit = 15;
 }  // namespace

 using BrowserCommand = browser_command::mojom::Command;

 bool WhatsNewModule::HasFeature() const {
   return feature_ != nullptr;
 }

 bool WhatsNewModule::HasActiveFeature() const {
   if (!HasFeature()) {
     return false;
   }
   return base::FeatureList::IsEnabled(*feature_) &&
          feature_->default_state == base::FEATURE_DISABLED_BY_DEFAULT;
 }

 bool WhatsNewModule::HasRolledFeature() const {
   if (!HasFeature()) {
     return false;
   }
   return feature_->default_state == base::FEATURE_ENABLED_BY_DEFAULT;
 }

 bool WhatsNewModule::IsFeatureEnabled() const {
   CHECK(HasFeature());
   return base::FeatureList::IsEnabled(*feature_);
 }

 const char* WhatsNewModule::GetFeatureName() const {
   CHECK(feature_);
   return feature_->name;
 }

 const std::string WhatsNewModule::GetCustomization() const {
   if (!feature_) {
     return "";
   }
   std::string customization = base::GetFieldTrialParamValueByFeature(
       *feature_, whats_new::kCustomizationParam);
   return customization;
 }

 WhatsNewEdition::WhatsNewEdition(const base::Feature& feature,
                                  std::string owner,
                                  std::vector<BrowserCommand> browser_commands)
     : feature_(feature),
       unique_name_(feature.name),
       browser_commands_(browser_commands) {}

 WhatsNewEdition::WhatsNewEdition(WhatsNewEdition&& other) = default;
 WhatsNewEdition::~WhatsNewEdition() = default;

 bool WhatsNewEdition::IsFeatureEnabled() const {
   return base::FeatureList::IsEnabled(*feature_);
 }

 const char* WhatsNewEdition::GetFeatureName() const {
   return feature_->name;
 }

 const std::string WhatsNewEdition::GetCustomization() const {
   std::string customization = base::GetFieldTrialParamValueByFeature(
       *feature_, whats_new::kCustomizationParam);
   return customization;
 }

 const std::optional<std::string> WhatsNewEdition::GetSurvey() const {
   std::string survey = base::GetFieldTrialParamValueByFeature(
       *feature_, whats_new::kSurveyParam);
   if (survey.empty()) {
     return std::nullopt;
   }
   return survey;
 }

 void WhatsNewRegistry::RegisterModule(WhatsNewModule module) {
   CHECK(!modules_.contains(module.unique_name()));
   if (module.HasFeature() && module.IsFeatureEnabled()) {
     storage_service_->SetModuleEnabled(module.GetFeatureName());
   }
   modules_.emplace(module.unique_name(), std::move(module));
 }

 void WhatsNewRegistry::RegisterEdition(WhatsNewEdition edition) {
   CHECK(!editions_.contains(edition.unique_name()));
   editions_.emplace(edition.unique_name(), std::move(edition));
 }

 const std::vector<BrowserCommand> WhatsNewRegistry::GetActiveCommands() const {
   std::vector<BrowserCommand> commands;
   for (const auto& [key, module] : modules_) {
     if (module.browser_command().has_value()) {
       // Modules without a feature are default-enabled.
       const bool module_is_default_enabled = !module.HasFeature();
       // If the module is tied to a feature, ensure the feature is available.
       const bool module_is_available =
           module.HasActiveFeature() || module.HasRolledFeature();
       if (module_is_default_enabled || module_is_available) {
         commands.emplace_back(module.browser_command().value());
       }
     }
   }
   for (const auto& [key, edition] : editions_) {
     // The only requirement for an edition to show is that it is enabled.
     if (edition.IsFeatureEnabled()) {
       for (const auto browser_command : edition.browser_commands()) {
         commands.emplace_back(browser_command);
       }
     }
   }
   return commands;
 }

 const std::vector<std::string_view> WhatsNewRegistry::GetActiveFeatureNames()
     const {
   std::vector<std::string_view> feature_names;

   // Check if the current version is used for an edition.
   const auto current_edition_name =
       storage_service_->FindEditionForCurrentVersion();
   if (current_edition_name.has_value()) {
     // An edition is tied to this milestone. Request this edition again.
     feature_names.emplace_back(*current_edition_name);
   } else if (!storage_service_->WasVersionPageUsedForCurrentMilestone()) {
     // Only request other unused editions if no other page was shown
     // during this milestone (version page or other edition page).
     for (const auto& [key, edition] : editions_) {
       if (edition.IsFeatureEnabled() &&
           feature_names.size() < kRequestEntropyLimit &&
           !storage_service_->IsUsedEdition(edition.GetFeatureName())) {
         feature_names.emplace_back(edition.GetFeatureName());
       }
     }
   }

   // Add modules based on ordered list.
   const base::Value::List& module_names_in_order =
       storage_service_->ReadModuleData();
   for (const base::Value& module_value : module_names_in_order) {
     if (feature_names.size() >= kRequestEntropyLimit) {
       break;
     }
     auto found_module = modules_.find(module_value.GetString());
     if (found_module != modules_.end() &&
         found_module->second.HasActiveFeature()) {
       feature_names.emplace_back(found_module->second.GetFeatureName());
     }
   }

   return feature_names;
 }

 const std::vector<std::string_view> WhatsNewRegistry::GetRolledFeatureNames()
     const {
   std::vector<std::string_view> feature_names;

   // Add modules based on ordered list.
   const base::Value::List& module_names_in_order =
       storage_service_->ReadModuleData();
   for (auto& module_value : module_names_in_order) {
     if (feature_names.size() >= kRequestEntropyLimit) {
       break;
     }
     auto found_module = modules_.find(module_value.GetString());
     if (found_module != modules_.end() &&
         found_module->second.HasRolledFeature()) {
       feature_names.emplace_back(found_module->second.GetFeatureName());
     }
   }

   return feature_names;
 }

 const std::vector<std::string> WhatsNewRegistry::GetCustomizations() const {
   std::vector<std::string> customizations;
   const base::Value::List& module_names_in_order =
       storage_service_->ReadModuleData();
   for (const base::Value& module_value : module_names_in_order) {
     auto found_module = modules_.find(module_value.GetString());
     if (found_module != modules_.end()) {
       auto module = found_module->second;

       // Modules without a feature are default-enabled.
       const bool module_is_default_enabled = !module.HasFeature();
       // If the module is tied to a feature, ensure the feature is available.
       const bool module_is_available =
           module.HasActiveFeature() || module.HasRolledFeature();
       if (module_is_default_enabled || module_is_available) {
         std::string customization = module.GetCustomization();
         if (!customization.empty()) {
           customizations.emplace_back(customization);
         }
       }
     }
   }
   for (const auto& [key, edition] : editions_) {
     // The only requirement for an edition to show is that it is enabled.
     if (edition.IsFeatureEnabled()) {
       const auto customization = edition.GetCustomization();
       if (!customization.empty()) {
         customizations.emplace_back(customization);
       }
     }
   }
   return customizations;
 }

 const std::optional<std::string> WhatsNewRegistry::GetActiveEditionSurvey()
     const {
   // Check if the current version is used for an edition.
   const auto current_edition_name =
       storage_service_->FindEditionForCurrentVersion();
   if (current_edition_name.has_value()) {
     auto found_edition = editions_.find(std::string(*current_edition_name));
     if (found_edition != editions_.end()) {
       return found_edition->second.GetSurvey();
     }
   } else {
     // Only request other unused editions if there was not one shown during
     // this version.
     for (const auto& [key, edition] : editions_) {
       if (edition.IsFeatureEnabled() &&
           !storage_service_->IsUsedEdition(edition.GetFeatureName())) {
         const auto survey = edition.GetSurvey();
         if (survey.has_value()) {
           return survey;
         }
       }
     }
   }

   return std::nullopt;
 }

 void WhatsNewRegistry::SetEditionUsed(std::string edition_name) const {
   // Verify edition exists.
   auto found_edition = editions_.find(edition_name);
   if (found_edition != editions_.end()) {
     storage_service_->SetEditionUsed(edition_name);
   }
 }

 void WhatsNewRegistry::SetVersionUsed() const {
   storage_service_->SetVersionUsed();
 }

 void WhatsNewRegistry::ClearUnregisteredModules() const {
   std::set<std::string_view> modules_to_clear;
   for (auto& module_value : storage_service_->ReadModuleData()) {
     auto found_module = modules_.find(module_value.GetString());
     // If the stored module cannot be found in the current registered
     // modules, clear its data.
     if (found_module == modules_.end()) {
       modules_to_clear.emplace(module_value.GetString());
     }
   }
   storage_service_->ClearModules(std::move(modules_to_clear));
 }

 void WhatsNewRegistry::ClearUnregisteredEditions() const {
   std::set<std::string_view> editions_to_clear;
   for (auto edition_value : storage_service_->ReadEditionData()) {
     auto found_edition = editions_.find(edition_value.first);
     // If the stored edition cannot be found in the current registered
     // editions, clear its data.
     if (found_edition == editions_.end()) {
       editions_to_clear.emplace(edition_value.first);
     }
   }
   storage_service_->ClearEditions(std::move(editions_to_clear));
 }

 void WhatsNewRegistry::ResetData() const {
   storage_service_->Reset();
 }

 WhatsNewRegistry::WhatsNewRegistry(
     std::unique_ptr<WhatsNewStorageService> storage_service)
     : storage_service_(std::move(storage_service)) {}
 WhatsNewRegistry::~WhatsNewRegistry() = default;

 }  // namespace whats_new
	// Copyright 2024 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/user_education/webui/whats_new_registry.h"

	#include "base/containers/contains.h"
	#include "base/metrics/field_trial_params.h"
	#include "base/values.h"
	#include "ui/webui/resources/js/browser_command/browser_command.mojom.h"

	namespace whats_new {
	namespace {
	constexpr int kRequestEntropyLimit = 15;
	} // namespace

	using BrowserCommand = browser_command::mojom::Command;

	bool WhatsNewModule::HasFeature() const {
	return feature_ != nullptr;
	}

	bool WhatsNewModule::HasActiveFeature() const {
	if (!HasFeature()) {
	return false;
	}
	return base::FeatureList::IsEnabled(*feature_) &&
	feature_->default_state == base::FEATURE_DISABLED_BY_DEFAULT;
	}

	bool WhatsNewModule::HasRolledFeature() const {
	if (!HasFeature()) {
	return false;
	}
	return feature_->default_state == base::FEATURE_ENABLED_BY_DEFAULT;
	}

	bool WhatsNewModule::IsFeatureEnabled() const {
	CHECK(HasFeature());
	return base::FeatureList::IsEnabled(*feature_);
	}

	const char* WhatsNewModule::GetFeatureName() const {
	CHECK(feature_);
	return feature_->name;
	}

	const std::string WhatsNewModule::GetCustomization() const {
	if (!feature_) {
	return "";
	}
	std::string customization = base::GetFieldTrialParamValueByFeature(
	*feature_, whats_new::kCustomizationParam);
	return customization;
	}

	WhatsNewEdition::WhatsNewEdition(const base::Feature& feature,
	std::string owner,
	std::vector<BrowserCommand> browser_commands)
	: feature_(feature),
	unique_name_(feature.name),
	browser_commands_(browser_commands) {}

	WhatsNewEdition::WhatsNewEdition(WhatsNewEdition&& other) = default;
	WhatsNewEdition::~WhatsNewEdition() = default;

	bool WhatsNewEdition::IsFeatureEnabled() const {
	return base::FeatureList::IsEnabled(*feature_);
	}

	const char* WhatsNewEdition::GetFeatureName() const {
	return feature_->name;
	}

	const std::string WhatsNewEdition::GetCustomization() const {
	std::string customization = base::GetFieldTrialParamValueByFeature(
	*feature_, whats_new::kCustomizationParam);
	return customization;
	}

	const std::optional<std::string> WhatsNewEdition::GetSurvey() const {
	std::string survey = base::GetFieldTrialParamValueByFeature(
	*feature_, whats_new::kSurveyParam);
	if (survey.empty()) {
	return std::nullopt;
	}
	return survey;
	}

	void WhatsNewRegistry::RegisterModule(WhatsNewModule module) {
	CHECK(!modules_.contains(module.unique_name()));
	if (module.HasFeature() && module.IsFeatureEnabled()) {
	storage_service_->SetModuleEnabled(module.GetFeatureName());
	}
	modules_.emplace(module.unique_name(), std::move(module));
	}

	void WhatsNewRegistry::RegisterEdition(WhatsNewEdition edition) {
	CHECK(!editions_.contains(edition.unique_name()));
	editions_.emplace(edition.unique_name(), std::move(edition));
	}

	const std::vector<BrowserCommand> WhatsNewRegistry::GetActiveCommands() const {
	std::vector<BrowserCommand> commands;
	for (const auto& [key, module] : modules_) {
	if (module.browser_command().has_value()) {
	// Modules without a feature are default-enabled.
	const bool module_is_default_enabled = !module.HasFeature();
	// If the module is tied to a feature, ensure the feature is available.
	const bool module_is_available =
	module.HasActiveFeature() \|\| module.HasRolledFeature();
	if (module_is_default_enabled \|\| module_is_available) {
	commands.emplace_back(module.browser_command().value());
	}
	}
	}
	for (const auto& [key, edition] : editions_) {
	// The only requirement for an edition to show is that it is enabled.
	if (edition.IsFeatureEnabled()) {
	for (const auto browser_command : edition.browser_commands()) {
	commands.emplace_back(browser_command);
	}
	}
	}
	return commands;
	}

	const std::vector<std::string_view> WhatsNewRegistry::GetActiveFeatureNames()
	const {
	std::vector<std::string_view> feature_names;

	// Check if the current version is used for an edition.
	const auto current_edition_name =
	storage_service_->FindEditionForCurrentVersion();
	if (current_edition_name.has_value()) {
	// An edition is tied to this milestone. Request this edition again.
	feature_names.emplace_back(*current_edition_name);
	} else if (!storage_service_->WasVersionPageUsedForCurrentMilestone()) {
	// Only request other unused editions if no other page was shown
	// during this milestone (version page or other edition page).
	for (const auto& [key, edition] : editions_) {
	if (edition.IsFeatureEnabled() &&
	feature_names.size() < kRequestEntropyLimit &&
	!storage_service_->IsUsedEdition(edition.GetFeatureName())) {
	feature_names.emplace_back(edition.GetFeatureName());
	}
	}
	}

	// Add modules based on ordered list.
	const base::Value::List& module_names_in_order =
	storage_service_->ReadModuleData();
	for (const base::Value& module_value : module_names_in_order) {
	if (feature_names.size() >= kRequestEntropyLimit) {
	break;
	}
	auto found_module = modules_.find(module_value.GetString());
	if (found_module != modules_.end() &&
	found_module->second.HasActiveFeature()) {
	feature_names.emplace_back(found_module->second.GetFeatureName());
	}
	}

	return feature_names;
	}

	const std::vector<std::string_view> WhatsNewRegistry::GetRolledFeatureNames()
	const {
	std::vector<std::string_view> feature_names;

	// Add modules based on ordered list.
	const base::Value::List& module_names_in_order =
	storage_service_->ReadModuleData();
	for (auto& module_value : module_names_in_order) {
	if (feature_names.size() >= kRequestEntropyLimit) {
	break;
	}
	auto found_module = modules_.find(module_value.GetString());
	if (found_module != modules_.end() &&
	found_module->second.HasRolledFeature()) {
	feature_names.emplace_back(found_module->second.GetFeatureName());
	}
	}

	return feature_names;
	}

	const std::vector<std::string> WhatsNewRegistry::GetCustomizations() const {
	std::vector<std::string> customizations;
	const base::Value::List& module_names_in_order =
	storage_service_->ReadModuleData();
	for (const base::Value& module_value : module_names_in_order) {
	auto found_module = modules_.find(module_value.GetString());
	if (found_module != modules_.end()) {
	auto module = found_module->second;

	// Modules without a feature are default-enabled.
	const bool module_is_default_enabled = !module.HasFeature();
	// If the module is tied to a feature, ensure the feature is available.
	const bool module_is_available =
	module.HasActiveFeature() \|\| module.HasRolledFeature();
	if (module_is_default_enabled \|\| module_is_available) {
	std::string customization = module.GetCustomization();
	if (!customization.empty()) {
	customizations.emplace_back(customization);
	}
	}
	}
	}
	for (const auto& [key, edition] : editions_) {
	// The only requirement for an edition to show is that it is enabled.
	if (edition.IsFeatureEnabled()) {
	const auto customization = edition.GetCustomization();
	if (!customization.empty()) {
	customizations.emplace_back(customization);
	}
	}
	}
	return customizations;
	}

	const std::optional<std::string> WhatsNewRegistry::GetActiveEditionSurvey()
	const {
	// Check if the current version is used for an edition.
	const auto current_edition_name =
	storage_service_->FindEditionForCurrentVersion();
	if (current_edition_name.has_value()) {
	auto found_edition = editions_.find(std::string(*current_edition_name));
	if (found_edition != editions_.end()) {
	return found_edition->second.GetSurvey();
	}
	} else {
	// Only request other unused editions if there was not one shown during
	// this version.
	for (const auto& [key, edition] : editions_) {
	if (edition.IsFeatureEnabled() &&
	!storage_service_->IsUsedEdition(edition.GetFeatureName())) {
	const auto survey = edition.GetSurvey();
	if (survey.has_value()) {
	return survey;
	}
	}
	}
	}

	return std::nullopt;
	}

	void WhatsNewRegistry::SetEditionUsed(std::string edition_name) const {
	// Verify edition exists.
	auto found_edition = editions_.find(edition_name);
	if (found_edition != editions_.end()) {
	storage_service_->SetEditionUsed(edition_name);
	}
	}

	void WhatsNewRegistry::SetVersionUsed() const {
	storage_service_->SetVersionUsed();
	}

	void WhatsNewRegistry::ClearUnregisteredModules() const {
	std::set<std::string_view> modules_to_clear;
	for (auto& module_value : storage_service_->ReadModuleData()) {
	auto found_module = modules_.find(module_value.GetString());
	// If the stored module cannot be found in the current registered
	// modules, clear its data.
	if (found_module == modules_.end()) {
	modules_to_clear.emplace(module_value.GetString());
	}
	}
	storage_service_->ClearModules(std::move(modules_to_clear));
	}

	void WhatsNewRegistry::ClearUnregisteredEditions() const {
	std::set<std::string_view> editions_to_clear;
	for (auto edition_value : storage_service_->ReadEditionData()) {
	auto found_edition = editions_.find(edition_value.first);
	// If the stored edition cannot be found in the current registered
	// editions, clear its data.
	if (found_edition == editions_.end()) {
	editions_to_clear.emplace(edition_value.first);
	}
	}
	storage_service_->ClearEditions(std::move(editions_to_clear));
	}

	void WhatsNewRegistry::ResetData() const {
	storage_service_->Reset();
	}

	WhatsNewRegistry::WhatsNewRegistry(
	std::unique_ptr<WhatsNewStorageService> storage_service)
	: storage_service_(std::move(storage_service)) {}
	WhatsNewRegistry::~WhatsNewRegistry() = default;

	} // namespace whats_new