Replace the 1 in 10 grace period with an accumulating budget based on SES.

chrome/browser/push_messaging/background_budget_service.cc

 // Copyright 2016 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/push_messaging/background_budget_service.h"
 
+#include <stdint.h>
+
 #include "base/callback.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "base/time/time.h"
+#include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 
 namespace {
 
-std::string GetBudgetStringForOrigin(Profile* profile, const GURL& origin) {
-  DCHECK_EQ(origin.GetOrigin(), origin);
+const char kSeparator = '#';
+const double kSecondsToAccumulate = 864000.0;  // 10 days of seconds.
+
+std::string GetBudgetDataFromPrefs(Profile* profile, const GURL& origin) {
   const base::DictionaryValue* map =
       profile->GetPrefs()->GetDictionary(prefs::kBackgroundBudgetMap);
 
   std::string map_string;
   map->GetStringWithoutPathExpansion(origin.spec(), &map_string);
   return map_string;
 }
 
+void SetBudgetDataInPrefs(Profile* profile,
+                          const GURL& origin,
+                          const std::string& data) {
+  DictionaryPrefUpdate update(profile->GetPrefs(), prefs::kBackgroundBudgetMap);
+  base::DictionaryValue* map = update.Get();
+
+  map->SetStringWithoutPathExpansion(origin.spec(), data);
+}
+
+// The value stored in prefs is a concatenated string of last updated time, old
+// budget, and old ses.
+std::string MakePrefValueFromBudgetData(const double budget, const double ses) {
+  base::Time t = base::Time::Now();
+  return base::DoubleToString(t.ToDoubleT()) + kSeparator +
+         base::DoubleToString(budget) + kSeparator + base::DoubleToString(ses);

[Peter Beverloo, 2016/04/14 18:02:09]

Please check out base/strings/stringprintf.h. If anything, avoids many possible
reallocations.

[harkness, 2016/04/27 11:21:08]

Done.

+}
+
+bool GetBudgetDataFromPrefValue(const std::string& pref_value,

[Peter Beverloo, 2016/04/14 18:02:09]

Can we combine this with GetBudgetDataFromPrefs? I'd rather keep the
parsing/combining logic as self-contained as possible.

Dito re: SetBudgetDataInPrefs and MakePrefValueFromBudgetData.

[harkness, 2016/04/27 11:21:08]

Done.

+                                double* old_budget,
+                                double* old_ses,
+                                double* last_updated) {
+  std::vector<std::string> parts =

[Peter Beverloo, 2016/04/14 18:02:08]

Please use base::SplitStringPiece() instead.

String pieces are very similar to C++17s std::string_view, i.e. they refer to
part of |pref_value|s memory and avoid the need to allocate for and copy each
chunk in the variable. In this case we're not modifying |pref_value|, so that
will be a much more elegant solution.

[harkness, 2016/04/27 11:21:08]

As discussed in person, there's currently no StringToDouble that takes a
StringPiece, so while I'm using SplitStringPiece, I'm still doing the
allocations using as_string(). I'll fix that in a future patch/CL.

+      base::SplitString(pref_value, std::string(1, kSeparator),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  if (parts.size() != 3)
+    return false;
+
+  if (!base::StringToDouble(parts[0], last_updated))
+    return false;
+
+  if (!base::StringToDouble(parts[1], old_budget))
+    return false;
+
+  if (!base::StringToDouble(parts[2], old_ses))
+    return false;
+
+  return true;
+}
+
 }  // namespace
 
 // static
 void BackgroundBudgetService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kBackgroundBudgetMap);
 }
 
 // static
-std::string BackgroundBudgetService::GetBudget(Profile* profile,
-                                               const GURL& origin) {
-  return GetBudgetStringForOrigin(profile, origin);
+void BackgroundBudgetService::GetBudget(Profile* profile,
+                                        const GURL& origin,
+                                        double& budget) {
+  // Get the current SES score, which we'll use to set a new budget.
+  SiteEngagementService* service = SiteEngagementService::Get(profile);
+  double ses_score = service->GetScore(origin);
+
+  // Get the last used budget data. This is a triple of last calculated time,
+  // budget at that time, and Site Engagement Score (ses) at that time.
+  const std::string map_value = GetBudgetDataFromPrefs(profile, origin);
+
+  // If there is no stored data, just return data based on the SES.
+  if (map_value.empty()) {
+    budget = ses_score;
+    return;
+  }
+
+  double old_budget = 0.0, old_ses = 0.0, last_updated_msec = 0.0;
+  if (!GetBudgetDataFromPrefValue(map_value, &old_budget, &old_ses,
+                                  &last_updated_msec)) {
+    budget = ses_score;
+    return;
+  }
+
+  base::Time now = base::Time::Now();
+  base::TimeDelta elapsed = now - base::Time::FromDoubleT(last_updated_msec);
+
+  // Budget recalculation consists of a budget carryover component, which
+  // rewards sites that don't use all their budgets every day, and a ses
+  // component, which gives extra budget to sites that have a high ses score.
+  double carryover_ratio = std::max(
+      0.0,
+      ((kSecondsToAccumulate - elapsed.InSeconds()) / kSecondsToAccumulate));
+  double budget_carryover = old_budget * carryover_ratio;
+  double ses_ratio =
+      std::min(1.0, (elapsed.InSeconds() / kSecondsToAccumulate));
+  double ses_component = (old_ses + ses_score) / 2 * ses_ratio;
+  budget = budget_carryover + ses_component;

[Peter Beverloo, 2016/04/14 18:02:09]

So we have a linear decrease of budget over a period of ten days, then calculate
the new budget by multiplying the average between the previous and current site
engagement scores and multiplying that by the |ses_ratio|. Does this match your
spreadsheet? :)

[harkness, 2016/04/27 11:21:08]

The original spreadsheet assumed that everything was only being calculated once
a day, so this algorithm is a slight change from the original, to include gaps
in when it's calculated. There are two new pages to the spreadsheet titled "Time
based..." which show the way the algorithm works with the time based variant,
where I've varied how often the budget is computed.  

 }
 
 // static
-void BackgroundBudgetService::StoreBudget(
-    Profile* profile,
-    const GURL& origin,
-    const std::string& notifications_shown) {
-  DictionaryPrefUpdate update(profile->GetPrefs(), prefs::kBackgroundBudgetMap);
-  base::DictionaryValue* map = update.Get();
-  map->SetStringWithoutPathExpansion(origin.spec(), notifications_shown);
+void BackgroundBudgetService::StoreBudget(Profile* profile,
+                                          const GURL& origin,
+                                          const double budget) {
+  // Get the current SES score to write into the prefs with the new budget.
+  SiteEngagementService* service = SiteEngagementService::Get(profile);
+  double ses_score = service->GetScore(origin);
+
+  std::string budget_string = MakePrefValueFromBudgetData(budget, ses_score);
+  SetBudgetDataInPrefs(profile, origin, budget_string);
 }