Introduce a request throttler for limiting requests in mobile NTP.

components/ntp_snippets/request_counter.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 "components/ntp_snippets/request_counter.h"
+
+#include <vector>
+
+#include "base/metrics/histogram.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "base/strings/stringprintf.h"
+#include "base/time/time.h"
+#include "components/ntp_snippets/ntp_snippets_constants.h"
+#include "components/ntp_snippets/pref_names.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
+#include "components/variations/variations_associated_data.h"
+
+namespace {
+
+const char kQuotaParamPrefix[] = "quota_";
+const char kUMAHistogramTotalFormat[] =
+    "NewTabPage.RequestCounter.RequestStatus_%s";
+const char kUMAHistogramPerDayFormat[] = "NewTabPage.RequestCounter.PerDay_%s";
+
+struct RequestTypeInfo {
+  const char* name;
+  const char* count_pref;
+  const char* day_pref;
+};
+
+// When adding a new type here, extend also the "RequestCounterTypes"
+// <histogram_suffixes> in histograms.xml with the |name| string. Register the
+// prefs below in RegisterProfilePrefs as well.
+using ntp_snippets::RequestCounter;
+const RequestTypeInfo kRequestTypeInfo[] = {
+     // RequestCounter::RequestType::ARTICLE_CONTENT_FETCHER,
+     {"Fetcher", ntp_snippets::prefs::kSnippetFetcherQuotaCount,
+      ntp_snippets::prefs::kSnippetFetcherQuotaDay}};
+
+}  // namespace
+
+namespace ntp_snippets {
+
+RequestCounter::RequestCounter(PrefService* pref_service,
+                               RequestType type,
+                               int default_quota)
+    : pref_service_(pref_service), type_(type) {
+  DCHECK(pref_service);
+
+  std::string quota = variations::GetVariationParamValue(
+      ntp_snippets::kStudyName, kQuotaParamPrefix + GetRequestTypeAsString());
+  if (!base::StringToInt(quota, &quota_)) {
+    LOG_IF(WARNING, !quota.empty())
+        << "Invalid variation parameter for quota for "
+        << GetRequestTypeAsString();
+    quota_ = default_quota;
+  }
+
+  // Construct the histogram that is used for every request. The other histogram

[Marc Treib, 2016/07/20 12:58:27]

s/Construct/Lookup

[jkrcal, 2016/07/20 14:20:17]

Done.

+  // is used only once per day, construct it on the fly.
+  int status_count = static_cast<int>(RequestStatus::REQUEST_STATUS_COUNT);
+  histogram_request_status_ = base::LinearHistogram::FactoryGet(
+      base::StringPrintf(kUMAHistogramTotalFormat,
+                         GetRequestTypeAsString().c_str()),
+      1, status_count, status_count + 1,

[Marc Treib, 2016/07/20 12:58:27]

Is this correct? I think you're adding one more bin to the histogram than you
need.

[jkrcal, 2016/07/20 14:20:17]

I emulate the behaviour of UMA_HISTOGRAM_ENUMERATION
(https://cs.chromium.org/chromium/src/base/metrics/histogram_macros.h?sq=packa...).
I did not dare to question correctness of this macro as there are multiple weird
things I do not understand (such as that the minimum must be set to 1 even
though 0 can be reported). Maybe they expect to have one bin for values beyond
the range for catching errors?

[Marc Treib, 2016/07/20 15:13:57]

Huh, indeed! I thought it was supposed to be "max" and "max + 1", but looks like
I was wrong.

+      base::HistogramBase::kUmaTargetedHistogramFlag);
+}
+
+// static
+void RequestCounter::RegisterProfilePrefs(PrefRegistrySimple* registry) {
+  registry->RegisterIntegerPref(ntp_snippets::prefs::kSnippetFetcherQuotaDay,
+                                0);
+  registry->RegisterIntegerPref(ntp_snippets::prefs::kSnippetFetcherQuotaCount,
+                                0);
+}
+
+bool RequestCounter::DemandQuota() {
+  ResetCounterIfDayChanged();
+
+  std::string count_pref_key = GetCountPref();
+  int new_count = pref_service_->GetInteger(count_pref_key) + 1;
+  pref_service_->SetInteger(count_pref_key, new_count);
+
+  bool available = (new_count <= quota_);
+  histogram_request_status_->Add(
+      static_cast<int>(available ? RequestStatus::QUOTA_GRANTED
+                                 : RequestStatus::QUOTA_EXCEEDED));
+  return available;
+}
+
+void RequestCounter::ReportForcedRequest() const {
+  histogram_request_status_->Add(static_cast<int>(RequestStatus::FORCED));
+}
+
+void RequestCounter::ResetCounterIfDayChanged() {
+  // The count of days since a fixed reference (the Unix epoch).
+  int now_day = (base::Time::Now() - base::Time::UnixEpoch()).InDays();
+  std::string day_pref_key = GetDaysPref();
+
+  if (!pref_service_->HasPrefPath(day_pref_key)) {
+    // The counter starts from 0 for the first time in this profile.
+    pref_service_->SetInteger(day_pref_key, now_day);
+  } else if (now_day != pref_service_->GetInteger(day_pref_key)) {
+    // Day has changed - report the number of requests from the previous day.
+    base::HistogramBase* histogram_per_day_ = base::Histogram::FactoryGet(
+        base::StringPrintf(kUMAHistogramPerDayFormat,
+                           GetRequestTypeAsString().c_str()),
+        1, 100, 50,
+        base::HistogramBase::kUmaTargetedHistogramFlag);
+
+    std::string count_pref_key = GetCountPref();
+    histogram_per_day_->Add(pref_service_->GetInteger(count_pref_key));
+    pref_service_->SetInteger(count_pref_key, 0);
+    pref_service_->SetInteger(day_pref_key, now_day);
+  }
+}
+
+std::string RequestCounter::GetRequestTypeAsString() const {
+  return kRequestTypeInfo[static_cast<int>(type_)].name;
+}
+
+std::string RequestCounter::GetCountPref() const {
+  return kRequestTypeInfo[static_cast<int>(type_)].count_pref;
+}
+
+std::string RequestCounter::GetDaysPref() const {
+  return kRequestTypeInfo[static_cast<int>(type_)].day_pref;
+}
+
+}  // namespace ntp_snippets