[Notification scheduler]: Finch config.

Implements reading config from Finch with unittest.

Bug: 1004498
Change-Id: Ib4326314d849cf66d8e702359a71fba74649471d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1808098
Commit-Queue: Hesen Zhang <hesen@chromium.org>
Auto-Submit: Hesen Zhang <hesen@chromium.org>
Reviewed-by: Xing Liu <xingliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#697058}

chrome/browser/notifications/scheduler/internal/BUILD.gn

@@ -89,6 +89,7 @@ source_set("unit_tests") {
     "notification_store_unittest.cc",
     "proto_conversion_unittest.cc",
     "scheduled_notification_manager_unittest.cc",
+    "scheduler_config_unittest.cc",
     "scheduler_utils_unittest.cc",
     "stats_unittest.cc",
   ]

chrome/browser/notifications/scheduler/internal/scheduler_config.cc

@@ -4,7 +4,37 @@
 
 #include "chrome/browser/notifications/scheduler/internal/scheduler_config.h"
 
+#include <string>
+
+#include "base/metrics/field_trial_params.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/notifications/scheduler/public/features.h"
+
 namespace notifications {
+namespace {
+
+// Helper routine to get Finch experiment parameter. If no Finch seed was
+// found,
+// use the |default_value|. The |name| should match an experiment
+// parameter in Finch server configuration.
+int GetFinchConfigUInt(const std::string& name, int default_value) {
+  return base::GetFieldTrialParamByFeatureAsInt(
+      features::kNotificationScheduleService, name, default_value);
+}
+
+}  // namespace
+
+// Default number of maximum daily shown all type.
+constexpr int kDefaultMaxDailyShownAllType = 3;
+
+// Default number of maximum daily shown per type.
+constexpr int kDefaultMaxDailyShownPerType = 10;
+
+// Default number of initial daily shown per type.
+constexpr int kDefaultInitialDailyShownPerType = 2;
+
+// Default number of dismiss count.
+constexpr int kDefaultDismissCount = 3;
 
 // The notification data is hold for one week.
 constexpr base::TimeDelta kDefaultNotificationExpiration =
@@ -20,7 +50,8 @@ constexpr base::TimeDelta kDefaultSuppressionDuration =
 
 // Check consecutive notification dismisses in this duration to generate a
 // dismiss event.
-constexpr base::TimeDelta kDefaultDimissDuration = base::TimeDelta::FromDays(7);
+constexpr base::TimeDelta kDefaultDismissDuration =
+    base::TimeDelta::FromDays(7);
 
 // Default background task time window duration.
 constexpr base::TimeDelta kDefaultBackgroundTaskWindowDuration =
@@ -31,18 +62,49 @@ std::unique_ptr<SchedulerConfig> SchedulerConfig::Create() {
   return std::make_unique<SchedulerConfig>();
 }
 
+std::unique_ptr<SchedulerConfig> SchedulerConfig::CreateFromFinch() {
+  std::unique_ptr<SchedulerConfig> config = std::make_unique<SchedulerConfig>();
+  config->max_daily_shown_all_type =
+      base::saturated_cast<int>(GetFinchConfigUInt(
+          kMaxDailyShownAllTypeConfig, kDefaultMaxDailyShownAllType));
+  config->max_daily_shown_per_type =
+      base::saturated_cast<int>(GetFinchConfigUInt(
+          kMaxDailyShownPerTypeConfig, kDefaultMaxDailyShownPerType));
+  config->initial_daily_shown_per_type =
+      base::saturated_cast<int>(GetFinchConfigUInt(
+          kInitialDailyShownPerTypeConfig, kDefaultInitialDailyShownPerType));
+  config->notification_expiration =
+      base::TimeDelta::FromDays(base::saturated_cast<int>(
+          GetFinchConfigUInt(kNotificationExpirationConfig,
+                             kDefaultNotificationExpiration.InDays())));
+  config->impression_expiration =
+      base::TimeDelta::FromDays(base::saturated_cast<int>(GetFinchConfigUInt(
+          kImpressionExpirationConfig, kDefaultImpressionExpiration.InDays())));
+  config->suppression_duration =
+      base::TimeDelta::FromDays(base::saturated_cast<int>(GetFinchConfigUInt(
+          kSuppressionDurationConfig, kDefaultSuppressionDuration.InDays())));
+  config->dismiss_count = base::saturated_cast<int>(
+      GetFinchConfigUInt(kDismissCountConfig, kDefaultDismissCount));
+  config->dismiss_duration =
+      base::TimeDelta::FromDays(base::saturated_cast<int>(GetFinchConfigUInt(
+          kDismissDurationConfig, kDefaultDismissDuration.InDays())));
+  config->background_task_window_duration =
+      base::TimeDelta::FromHours(base::saturated_cast<int>(
+          GetFinchConfigUInt(kBackgroundTaskWindowDurationConfig,
+                             kDefaultBackgroundTaskWindowDuration.InHours())));
+  return config;
+}
+
 SchedulerConfig::SchedulerConfig()
-    : max_daily_shown_all_type(3),
-      max_daily_shown_per_type(10),
-      initial_daily_shown_per_type(2),
+    : max_daily_shown_all_type(kDefaultMaxDailyShownAllType),
+      max_daily_shown_per_type(kDefaultMaxDailyShownPerType),
+      initial_daily_shown_per_type(kDefaultInitialDailyShownPerType),
       notification_expiration(kDefaultNotificationExpiration),
       impression_expiration(kDefaultImpressionExpiration),
       suppression_duration(kDefaultSuppressionDuration),
-      dismiss_count(3),
-      dismiss_duration(kDefaultDimissDuration),
-      background_task_window_duration(kDefaultBackgroundTaskWindowDuration) {
-  // TODO(xingliu): Add constructor using finch data.
-}
+      dismiss_count(kDefaultDismissCount),
+      dismiss_duration(kDefaultDismissDuration),
+      background_task_window_duration(kDefaultBackgroundTaskWindowDuration) {}
 
 SchedulerConfig::~SchedulerConfig() = default;
 

chrome/browser/notifications/scheduler/internal/scheduler_config.h

@@ -12,11 +12,43 @@
 
 namespace notifications {
 
+// Configure the maxmium number of notifications daily shown for all types.
+constexpr char kMaxDailyShownAllTypeConfig[] = "max_daily_shown_all_type";
+
+// Configure the maxmium number of notifications daily shown per type.
+constexpr char kMaxDailyShownPerTypeConfig[] = "max_daily_shown_per_type";
+
+// Configure the initial number of notifications daily shown per type.
+constexpr char kInitialDailyShownPerTypeConfig[] =
+    "initial_daily_shown_per_type";
+
+// Configure the expiration duration for notifications.
+constexpr char kNotificationExpirationConfig[] =
+    "notification_expiration_in_days";
+
+// Configure the expiration duration for impressions.
+constexpr char kImpressionExpirationConfig[] = "impression_expiration_in_days";
+
+// Configure the expiration duration for suppression.
+constexpr char kSuppressionDurationConfig[] = "suppression_duration_in_days";
+
+// Configure the number of dismiss count.
+constexpr char kDismissCountConfig[] = "dismiss_count";
+
+// Configure the duration of a dismiss.
+constexpr char kDismissDurationConfig[] = "dismiss_duration_in_days";
+
+// Configure the duration of background task window.
+constexpr char kBackgroundTaskWindowDurationConfig[] =
+    "background_task_window_duration_in_hours";
+
 // Configuration of notification scheduler system.
 struct SchedulerConfig {
   // Creates a default scheduler config.
   static std::unique_ptr<SchedulerConfig> Create();
 
+  static std::unique_ptr<SchedulerConfig> CreateFromFinch();
+
   SchedulerConfig();
   ~SchedulerConfig();
 

chrome/browser/notifications/scheduler/internal/scheduler_config_unittest.cc

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/notifications/scheduler/internal/scheduler_config.h"
+
+#include <map>
+#include <string>
+
+#include "base/strings/string_number_conversions.h"
+#include "base/test/scoped_feature_list.h"
+#include "chrome/browser/notifications/scheduler/public/features.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace notifications {
+namespace {
+
+TEST(SchedulerConfigTest, FinchConfigTest) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  std::map<std::string, std::string> parameters = {
+      {kMaxDailyShownAllTypeConfig, base::NumberToString(123)},
+      {kMaxDailyShownPerTypeConfig, base::NumberToString(67)},
+      {kInitialDailyShownPerTypeConfig, base::NumberToString(45)},
+      {kNotificationExpirationConfig, base::NumberToString(33)},
+      {kImpressionExpirationConfig, base::NumberToString(22)},
+      {kSuppressionDurationConfig, base::NumberToString(11)},
+      {kDismissCountConfig, base::NumberToString(8)},
+      {kDismissDurationConfig, base::NumberToString(7)},
+      {kBackgroundTaskWindowDurationConfig, base::NumberToString(6)},
+  };
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      features::kNotificationScheduleService, parameters);
+  std::unique_ptr<SchedulerConfig> config = SchedulerConfig::CreateFromFinch();
+
+  EXPECT_EQ(config->max_daily_shown_all_type, 123);
+  EXPECT_EQ(config->max_daily_shown_per_type, 67);
+  EXPECT_EQ(config->initial_daily_shown_per_type, 45);
+  EXPECT_EQ(config->notification_expiration.InDays(), 33);
+  EXPECT_EQ(config->impression_expiration.InDays(), 22);
+  EXPECT_EQ(config->suppression_duration.InDays(), 11);
+  EXPECT_EQ(config->dismiss_count, 8);
+  EXPECT_EQ(config->background_task_window_duration.InHours(), 6);
+}
+
+}  // namespace
+}  // namespace notifications