Cherry pick PR #3173: Simplify PersistentSettings.

cobalt/browser/application.cc

@@ -1517,10 +1517,18 @@ void Application::InitMetrics() {
       metrics::CobaltMetricsServicesManager::GetInstance();
   // Before initializing metrics manager, set any persisted settings like if
   // it's enabled or upload interval.
-  bool is_metrics_enabled = persistent_settings_->GetPersistentSettingAsBool(
-      metrics::kMetricEnabledSettingName, false);
-  auto metric_event_interval = persistent_settings_->GetPersistentSettingAsInt(
-      metrics::kMetricEventIntervalSettingName, 300);
+  bool is_metrics_enabled;
+  {
+    base::Value value;
+    persistent_settings_->Get(metrics::kMetricEnabledSettingName, &value);
+    is_metrics_enabled = value.GetIfBool().value_or(false);
+  }
+  int metric_event_interval;
+  {
+    base::Value value;
+    persistent_settings_->Get(metrics::kMetricEventIntervalSettingName, &value);
+    metric_event_interval = value.GetIfInt().value_or(300);
+  }
   metrics_services_manager_->SetEventDispatcher(&event_dispatcher_);
   metrics_services_manager_->SetUploadInterval(metric_event_interval);
   metrics_services_manager_->ToggleMetricsEnabled(is_metrics_enabled);

cobalt/browser/browser_module.cc

@@ -791,7 +791,7 @@ void BrowserModule::OnLoad() {
 
   web_module_loaded_.Signal();
 
-  options_.persistent_settings->ValidatePersistentSettings();
+  options_.persistent_settings->Validate();
   ValidateCacheBackendSettings();
 }
 

cobalt/h5vcc/h5vcc_metrics.cc

@@ -119,9 +119,8 @@ script::HandlePromiseVoid H5vccMetrics::Disable(
 
 void H5vccMetrics::ToggleMetricsEnabled(bool is_enabled,
                                         base::OnceClosure done_callback) {
-  persistent_settings_->SetPersistentSetting(
-      browser::metrics::kMetricEnabledSettingName,
-      std::make_unique<base::Value>(is_enabled));
+  persistent_settings_->Set(browser::metrics::kMetricEnabledSettingName,
+                            base::Value(is_enabled));
   browser::metrics::CobaltMetricsServicesManager::GetInstance()
       ->ToggleMetricsEnabled(is_enabled, std::move(done_callback));
 }
@@ -132,9 +131,8 @@ bool H5vccMetrics::IsEnabled() {
 }
 
 void H5vccMetrics::SetMetricEventInterval(uint32_t interval_seconds) {
-  persistent_settings_->SetPersistentSetting(
-      browser::metrics::kMetricEventIntervalSettingName,
-      std::make_unique<base::Value>(static_cast<int>(interval_seconds)));
+  persistent_settings_->Set(browser::metrics::kMetricEventIntervalSettingName,
+                            base::Value(static_cast<int>(interval_seconds)));
   browser::metrics::CobaltMetricsServicesManager::GetInstance()
       ->SetUploadInterval(interval_seconds);
 }

cobalt/h5vcc/h5vcc_settings.cc

@@ -84,9 +84,8 @@ bool H5vccSettings::Set(const std::string& name, SetValueType value) const {
     if (!persistent_settings_) {
       return false;
     } else {
-      persistent_settings_->SetPersistentSetting(
-          network::kQuicEnabledPersistentSettingsKey,
-          std::make_unique<base::Value>(value.AsType<int32>() != 0));
+      persistent_settings_->Set(network::kQuicEnabledPersistentSettingsKey,
+                                base::Value(value.AsType<int32>() != 0));
       // Tell NetworkModule (if exists) to re-query persistent settings.
       if (network_module_) {
         network_module_->SetEnableQuicFromPersistentSettings();
@@ -107,16 +106,16 @@ bool H5vccSettings::Set(const std::string& name, SetValueType value) const {
 void H5vccSettings::SetPersistentSettingAsInt(const std::string& key,
                                               int value) const {
   if (persistent_settings_) {
-    persistent_settings_->SetPersistentSetting(
-        key, std::make_unique<base::Value>(value));
+    persistent_settings_->Set(key, base::Value(value));
   }
 }
 
 int H5vccSettings::GetPersistentSettingAsInt(const std::string& key,
                                              int default_setting) const {
   if (persistent_settings_) {
-    return persistent_settings_->GetPersistentSettingAsInt(key,
-                                                           default_setting);
+    base::Value value;
+    persistent_settings_->Get(key, &value);
+    return value.GetIfInt().value_or(default_setting);
   }
   return default_setting;
 }

cobalt/h5vcc/h5vcc_storage.cc

@@ -372,9 +372,9 @@ H5vccStorageResourceTypeQuotaBytesDictionary H5vccStorage::GetQuota() {
 }
 
 void H5vccStorage::EnableCache() {
-  persistent_settings_->SetPersistentSetting(
+  persistent_settings_->Set(
       network::disk_cache::kCacheEnabledPersistentSettingsKey,
-      std::make_unique<base::Value>(true));
+      base::Value(true));
 
   network::disk_cache::settings::SetCacheEnabled(true);
 
@@ -384,9 +384,9 @@ void H5vccStorage::EnableCache() {
 }
 
 void H5vccStorage::DisableCache() {
-  persistent_settings_->SetPersistentSetting(
+  persistent_settings_->Set(
       network::disk_cache::kCacheEnabledPersistentSettingsKey,
-      std::make_unique<base::Value>(false));
+      base::Value(false));
 
   network::disk_cache::settings::SetCacheEnabled(false);
 

cobalt/network/network_module.cc

@@ -109,8 +109,10 @@ void NetworkModule::SetProxy(const std::string& custom_proxy_rules) {
 void NetworkModule::SetEnableQuicFromPersistentSettings() {
   // Called on initialization and when the persistent setting is changed.
   if (options_.persistent_settings != nullptr) {
-    bool enable_quic = options_.persistent_settings->GetPersistentSettingAsBool(
-        kQuicEnabledPersistentSettingsKey, false);
+    base::Value value;
+    options_.persistent_settings->Get(kQuicEnabledPersistentSettingsKey,
+                                      &value);
+    bool enable_quic = value.GetIfBool().value_or(false);
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&URLRequestContext::SetEnableQuic,

cobalt/network/url_request_context.cc

@@ -71,9 +71,10 @@ void LoadDiskCacheQuotaSettings(
     disk_cache::ResourceType resource_type = (disk_cache::ResourceType)i;
     std::string directory =
         disk_cache::defaults::GetSubdirectory(resource_type);
-    uint32_t bucket_size =
-        static_cast<uint32_t>(settings->GetPersistentSettingAsDouble(
-            directory, disk_cache::defaults::GetQuota(resource_type)));
+    base::Value value;
+    settings->Get(directory, &value);
+    uint32_t bucket_size = static_cast<uint32_t>(value.GetIfDouble().value_or(
+        disk_cache::defaults::GetQuota(resource_type)));
     quotas[resource_type] = bucket_size;
     total_size += bucket_size;
   }
@@ -93,9 +94,7 @@ void LoadDiskCacheQuotaSettings(
     disk_cache::settings::SetQuota(resource_type, default_quota);
     std::string directory =
         disk_cache::defaults::GetSubdirectory(resource_type);
-    settings->SetPersistentSetting(
-        directory,
-        std::make_unique<base::Value>(static_cast<double>(default_quota)));
+    settings->Set(directory, base::Value(static_cast<double>(default_quota)));
   }
 }
 
@@ -283,9 +282,10 @@ URLRequestContext::URLRequestContext(
                       /* max_bytes */ max_cache_bytes, url_request_context));
               http_cache->set_can_disable_by_mime_type(true);
               if (persistent_settings != nullptr) {
-                auto cache_enabled =
-                    persistent_settings->GetPersistentSettingAsBool(
-                        disk_cache::kCacheEnabledPersistentSettingsKey, true);
+                base::Value value;
+                persistent_settings->Get(
+                    disk_cache::kCacheEnabledPersistentSettingsKey, &value);
+                auto cache_enabled = value.GetIfBool().value_or(true);
                 disk_cache::settings::SetCacheEnabled(cache_enabled);
                 if (!cache_enabled) {
                   http_cache->set_mode(net::HttpCache::Mode::DISABLE);
@@ -338,13 +338,12 @@ void URLRequestContext::OnQuicToggle(const std::string& message) {
 void URLRequestContext::UpdateCacheSizeSetting(disk_cache::ResourceType type,
                                                uint32_t bytes) {
   CHECK(cache_persistent_settings_);
-  cache_persistent_settings_->SetPersistentSetting(
-      disk_cache::defaults::GetSubdirectory(type),
-      std::make_unique<base::Value>(static_cast<double>(bytes)));
+  cache_persistent_settings_->Set(disk_cache::defaults::GetSubdirectory(type),
+                                  base::Value(static_cast<double>(bytes)));
 }
 
 void URLRequestContext::ValidateCachePersistentSettings() {
-  cache_persistent_settings_->ValidatePersistentSettings();
+  cache_persistent_settings_->Validate();
 }
 
 void URLRequestContext::AssociateKeyWithResourceType(