[NTP] Cleanup: add brackets in components/ntp_snippets. [2/2]

components/ntp_snippets/user_classifier.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/user_classifier.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <string>
 
@@ skipping 135 matching lines @@
 
 // Compute the number of hours between two events for the given metric value
 // assuming the events were equally distributed.
 double GetEstimateHoursBetweenEvents(double metric_value,
                                      double discount_rate_per_hour,
                                      double min_hours,
                                      double max_hours) {
   // The computation below is well-defined only for |metric_value| > 1 (log of
   // negative value or division by zero). When |metric_value| -> 1, the estimate
   // below -> infinity, so max_hours is a natural result, here.
-  if (metric_value <= 1)
+  if (metric_value <= 1) {
     return max_hours;
+  }
 
   // This is the estimate with the assumption that last event happened right
   // now and the system is in the steady-state. Solve estimate_hours in the
   // steady-state equation:
   //   metric_value = 1 + e^{-discount_rate * estimate_hours} * metric_value,
   // i.e.
   //   -discount_rate * estimate_hours = log((metric_value - 1) / metric_value),
   //   discount_rate * estimate_hours = log(metric_value / (metric_value - 1)),
   //   estimate_hours = log(metric_value / (metric_value - 1)) / discount_rate.
   double estimate_hours =
@@ skipping 25 matching lines @@
       discount_rate_per_hour_(GetDiscountRatePerHour()),
       min_hours_(GetMinHours()),
       max_hours_(GetMaxHours()),
       active_consumer_scrolls_at_least_once_per_hours_(
           GetParamValue(kActiveConsumerScrollsAtLeastOncePerHoursParam,
                         kActiveConsumerScrollsAtLeastOncePerHours)),
       rare_user_opens_ntp_at_most_once_per_hours_(
           GetParamValue(kRareUserOpensNTPAtMostOncePerHoursParam,
                         kRareUserOpensNTPAtMostOncePerHours)) {
   // The pref_service_ can be null in tests.
-  if (!pref_service_)
+  if (!pref_service_) {
     return;
+  }
 
   // TODO(jkrcal): Store the current discount rate per hour into prefs. If it
   // differs from the previous value, rescale the metric values so that the
   // expectation does not change abruptly!
 
   // Initialize the prefs storing the last time: the counter has just started!
   for (const Metric metric : kMetrics) {
-    if (!HasLastTime(metric))
+    if (!HasLastTime(metric)) {
       SetLastTimeToNow(metric);
+    }
   }
 }
 
 UserClassifier::~UserClassifier() = default;
 
 // static
 void UserClassifier::RegisterProfilePrefs(PrefRegistrySimple* registry) {
   double discount_rate = GetDiscountRatePerHour();
   double min_hours = GetMinHours();
   double max_hours = GetMaxHours();
@@ skipping 37 matching lines @@
 
 double UserClassifier::GetEstimatedAvgTime(Metric metric) const {
   DCHECK_NE(metric, Metric::COUNT);
   double metric_value = GetUpToDateMetricValue(metric);
   return GetEstimateHoursBetweenEvents(metric_value, discount_rate_per_hour_,
                                        min_hours_, max_hours_);
 }
 
 UserClassifier::UserClass UserClassifier::GetUserClass() const {
   // The pref_service_ can be null in tests.
-  if (!pref_service_)
+  if (!pref_service_) {
     return UserClass::ACTIVE_NTP_USER;
+  }
 
   if (GetEstimatedAvgTime(Metric::NTP_OPENED) >=
       rare_user_opens_ntp_at_most_once_per_hours_) {
     return UserClass::RARE_NTP_USER;
   }
 
   if (GetEstimatedAvgTime(Metric::SUGGESTIONS_SHOWN) <=
       active_consumer_scrolls_at_least_once_per_hours_) {
     return UserClass::ACTIVE_SUGGESTIONS_CONSUMER;
   }
 
   return UserClass::ACTIVE_NTP_USER;
 }
 
 std::string UserClassifier::GetUserClassDescriptionForDebugging() const {
   switch (GetUserClass()) {
     case UserClass::RARE_NTP_USER:
       return "Rare user of the NTP";
     case UserClass::ACTIVE_NTP_USER:
       return "Active user of the NTP";
     case UserClass::ACTIVE_SUGGESTIONS_CONSUMER:
       return "Active consumer of NTP suggestions";
   }
   NOTREACHED();
   return std::string();
 }
 
 void UserClassifier::ClearClassificationForDebugging() {
   // The pref_service_ can be null in tests.
-  if (!pref_service_)
+  if (!pref_service_) {
     return;
+  }
 
   for (const Metric& metric : kMetrics) {
     ClearMetricValue(metric);
     SetLastTimeToNow(metric);
   }
 }
 
 double UserClassifier::UpdateMetricOnEvent(Metric metric) {
   // The pref_service_ can be null in tests.
-  if (!pref_service_)
+  if (!pref_service_) {
     return 0;
+  }
 
   double hours_since_last_time =
       std::min(max_hours_, GetHoursSinceLastTime(metric));
   // Ignore events within the same "browsing session".
-  if (hours_since_last_time < min_hours_)
+  if (hours_since_last_time < min_hours_) {
     return GetUpToDateMetricValue(metric);
+  }
 
   SetLastTimeToNow(metric);
 
   double metric_value = GetMetricValue(metric);
   // Add 1 to the discounted metric as the event has happened right now.
   double new_metric_value =
       1 + DiscountMetric(metric_value, hours_since_last_time,
                           discount_rate_per_hour_);
   SetMetricValue(metric, new_metric_value);
   return new_metric_value;
 }
 
 double UserClassifier::GetUpToDateMetricValue(Metric metric) const {
   // The pref_service_ can be null in tests.
-  if (!pref_service_)
+  if (!pref_service_) {
     return 0;
+  }
 
   double hours_since_last_time =
       std::min(max_hours_, GetHoursSinceLastTime(metric));
 
   double metric_value = GetMetricValue(metric);
   return DiscountMetric(metric_value, hours_since_last_time,
                         discount_rate_per_hour_);
 }
 
 double UserClassifier::GetHoursSinceLastTime(Metric metric) const {
-  if (!HasLastTime(metric))
+  if (!HasLastTime(metric)) {
     return 0;
+  }
 
   base::TimeDelta since_last_time =
       base::Time::Now() - base::Time::FromInternalValue(pref_service_->GetInt64(
                               kLastTimeKeys[static_cast<int>(metric)]));
   return since_last_time.InSecondsF() / 3600;
 }
 
 bool UserClassifier::HasLastTime(Metric metric) const {
   return pref_service_->HasPrefPath(kLastTimeKeys[static_cast<int>(metric)]);
 }
 
 void UserClassifier::SetLastTimeToNow(Metric metric) {
   pref_service_->SetInt64(kLastTimeKeys[static_cast<int>(metric)],
                           base::Time::Now().ToInternalValue());
 }
 
 double UserClassifier::GetMetricValue(Metric metric) const {
   return pref_service_->GetDouble(kMetricKeys[static_cast<int>(metric)]);
 }
 
 void UserClassifier::SetMetricValue(Metric metric, double metric_value) {
   pref_service_->SetDouble(kMetricKeys[static_cast<int>(metric)], metric_value);
 }
 
 void UserClassifier::ClearMetricValue(Metric metric) {
   pref_service_->ClearPref(kMetricKeys[static_cast<int>(metric)]);
 }
 
 }  // namespace ntp_snippets