Added UMA stats to track the budget for any service worker which receives a

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/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.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 {
 
 constexpr char kSeparator = '#';
-// We calculate the ratio of the different components of a budget with respect
+
+// Calculate the ratio of the different components of a budget with respect
 // to a maximum time period of 10 days = 864000.0 seconds.
 constexpr double kSecondsToAccumulate = 864000.0;
 
+// Currently this just costs 2.0, but it may expand to include things like
+// whether wifi is available in the mobile case.
+const double kBackgroundProcessingCost = 2.0;

[Peter Beverloo, 2016/05/17 11:04:34]

What's your take on explicitly calling out that this is the budget for
notifications, rather than "background processing" in general? (Similar to
SiteEngagementScore::Get*Points().)

[harkness, 2016/05/17 13:08:16]

I've split it out now, although it makes the SES recording for no/low budget a
bit weird if there could be different costs. However, that will be an issue
we'll have to deal with when we go with the tri state anyway.

+
 bool GetBudgetDataFromPrefs(Profile* profile,
                             const GURL& origin,
                             double* old_budget,
                             double* old_ses,
                             double* last_updated) {
   const base::DictionaryValue* map =
       profile->GetPrefs()->GetDictionary(prefs::kBackgroundBudgetMap);
 
   std::string map_string;
   map->GetStringWithoutPathExpansion(origin.spec(), &map_string);
@@ skipping 32 matching lines @@
                           double budget,
                           double ses) {
   std::string s = base::StringPrintf("%f%c%f%c%f", last_updated, kSeparator,
                                      budget, kSeparator, ses);
   DictionaryPrefUpdate update(profile->GetPrefs(), prefs::kBackgroundBudgetMap);
   base::DictionaryValue* map = update.Get();
 
   map->SetStringWithoutPathExpansion(origin.spec(), s);
 }
 
+void RecordSESForNoBudgetOrigin(double ses) {
+  UMA_HISTOGRAM_COUNTS("PushMessaging.SESForNoBudgetOrigin", ses);
+}
+
+void RecordSESForLowBudgetOrigin(double ses) {
+  UMA_HISTOGRAM_COUNTS("PushMessaging.SESForLowBudgetOrigin", ses);

[Peter Beverloo, 2016/05/17 11:04:34]

Can we just inline these calls? No need for them to have their own methods,
since they're only used once.

[harkness, 2016/05/17 13:08:16]

Done.

+}
+
 }  // namespace
 
 BackgroundBudgetService::BackgroundBudgetService(Profile* profile)
     : clock_(base::WrapUnique(new base::DefaultClock)), profile_(profile) {
   DCHECK(profile);
 }
 
 BackgroundBudgetService::~BackgroundBudgetService() {}
 
 // static
 void BackgroundBudgetService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kBackgroundBudgetMap);
 }
 
+// static
+double BackgroundBudgetService::GetBackgroundProcessingCost() {
+  return kBackgroundProcessingCost;
+}
+
 double BackgroundBudgetService::GetBudget(const GURL& origin) {
   DCHECK_EQ(origin, origin.GetOrigin());
 
   // 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.
   double old_budget = 0.0, old_ses = 0.0, last_updated_msec = 0.0;
@@ skipping 21 matching lines @@
   // total period.
   double ses_ratio =
       std::min(1.0, (elapsed.InSeconds() / kSecondsToAccumulate));
   double ses_component = (old_ses + ses_score) / 2 * ses_ratio;
 
   // 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 budget = budget_carryover + ses_component;
   DCHECK_GE(budget, 0.0);
+
+  // Generate histograms for the GetBudget calls which would return "no budget"
+  // or "low budget" if an API was available to app developers.
+  if (budget < GetBackgroundProcessingCost())
+    RecordSESForNoBudgetOrigin(ses_score);
+  else if (budget < 2.0 * GetBackgroundProcessingCost())
+    RecordSESForLowBudgetOrigin(ses_score);
+
   return budget;
 }
 
 void BackgroundBudgetService::StoreBudget(const GURL& origin, double budget) {
   DCHECK_EQ(origin, origin.GetOrigin());
   DCHECK_GE(budget, 0.0);
   DCHECK_LE(budget, SiteEngagementScore::kMaxPoints);
 
   // 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);
 
   base::Time time = clock_->Now();
   SetBudgetDataInPrefs(profile_, origin, time.ToDoubleT(), budget, ses_score);
 }
 
 // Override the default clock with the specified clock. Only used for testing.
 void BackgroundBudgetService::SetClockForTesting(
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }