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;
+  }
+
+  // Lookup the histograms.
+  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,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+
+  histogram_per_day_ = base::Histogram::FactoryGet(
+      base::StringPrintf(kUMAHistogramPerDayFormat,
+                         GetRequestTypeAsString().c_str()),
+      1, 100, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
+}
+
+// static
+void RequestCounter::RegisterProfilePrefs(PrefRegistrySimple* registry) {
+  for (unsigned int i = 0; i < arraysize(kRequestTypeInfo); i++) {

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

I think you can use a range-based for loop:
for (const RequestTypeInfo& info : kRequestTypeInfo)

[jkrcal, 2016/07/20 15:46:23]

Indeed! 
Is it a general C++(11) feature or is there some chrome magic involved (as for
arraysize())?

[Marc Treib, 2016/07/20 16:15:14]

It's a C++11 thing, in particular non-member begin/end I think (which might be
implemented in a similar way to the arraysize() magic, but the behavior is
defined in the standard).

[jkrcal, 2016/07/21 07:44:27]

Thanks!

+    registry->RegisterIntegerPref(kRequestTypeInfo[i].count_pref, 0);
+    registry->RegisterIntegerPref(kRequestTypeInfo[i].day_pref, 0);
+  }
+}
+
+bool RequestCounter::DemandQuotaForRequest() {
+  ResetCounterIfDayChanged();
+
+  int new_count = GetCount() + 1;
+  SetCount(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();
+
+  if (!HasDay()) {
+    // The counter is used for the first time in this profile.
+    SetDay(now_day);
+  } else if (now_day != GetDay()) {
+    // Day has changed - report the number of requests from the previous day.
+    histogram_per_day_->Add(GetCount());
+    // Reset the counter.
+    SetCount(0);
+    SetDay(now_day);
+  }
+}
+
+std::string RequestCounter::GetRequestTypeAsString() const {
+  return kRequestTypeInfo[static_cast<int>(type_)].name;
+}
+
+int RequestCounter::GetCount() const {
+  return pref_service_->GetInteger(
+      kRequestTypeInfo[static_cast<int>(type_)].count_pref);
+}
+
+void RequestCounter::SetCount(int count) {
+  pref_service_->SetInteger(
+      kRequestTypeInfo[static_cast<int>(type_)].count_pref, count);
+}
+
+int RequestCounter::GetDay() const {
+  return pref_service_->GetInteger(
+      kRequestTypeInfo[static_cast<int>(type_)].day_pref);
+}
+
+void RequestCounter::SetDay(int day) {
+  pref_service_->SetInteger(
+      kRequestTypeInfo[static_cast<int>(type_)].day_pref, day);
+}
+
+bool RequestCounter::HasDay() const {
+  return pref_service_->HasPrefPath(
+      kRequestTypeInfo[static_cast<int>(type_)].day_pref);

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

optional: You could store a reference to the proper RequestTypeInfo as a member.

[jkrcal, 2016/07/20 15:46:23]

Done.

+}
+
+}  // namespace ntp_snippets