Refactoring a code pattern in previews_experiments.cc

components/previews/core/previews_experiments.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/previews/core/previews_experiments.h"
 
 #include <map>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 71 matching lines @@
   return it == experiment_params.end() ? std::string() : it->second;
 }
 
 }  // namespace
 
 namespace params {
 
 size_t MaxStoredHistoryLengthForPerHostBlackList() {
   std::string param_value = ParamValue(kMaxStoredHistoryLengthPerHost);
   size_t history_length;
-  if (!base::StringToSizeT(param_value, &history_length)) {
-    return 4;
-  }
+  if (!base::StringToSizeT(param_value, &history_length))
+    history_length = 4;
   return history_length;
 }
 
 size_t MaxStoredHistoryLengthForHostIndifferentBlackList() {
   std::string param_value = ParamValue(kMaxStoredHistoryLengthHostIndifferent);
   size_t history_length;
-  if (!base::StringToSizeT(param_value, &history_length)) {
-    return 10;
-  }
+  if (!base::StringToSizeT(param_value, &history_length))
+    history_length = 10;
   return history_length;
 }
 
 size_t MaxInMemoryHostsInBlackList() {
   std::string param_value = ParamValue(kMaxHostsInBlackList);
   size_t max_hosts;
-  if (!base::StringToSizeT(param_value, &max_hosts)) {
-    return 100;
-  }
+  if (!base::StringToSizeT(param_value, &max_hosts))
+    max_hosts = 100;
   return max_hosts;
 }
 
 int PerHostBlackListOptOutThreshold() {
   std::string param_value = ParamValue(kPerHostOptOutThreshold);
   int opt_out_threshold;
-  if (!base::StringToInt(param_value, &opt_out_threshold)) {
-    return 2;
-  }
+  if (!base::StringToInt(param_value, &opt_out_threshold))
+    opt_out_threshold = 2;
   return opt_out_threshold;
 }
 
 int HostIndifferentBlackListOptOutThreshold() {
   std::string param_value = ParamValue(kHostIndifferentOptOutThreshold);
   int opt_out_threshold;
-  if (!base::StringToInt(param_value, &opt_out_threshold)) {
-    return 4;
-  }
+  if (!base::StringToInt(param_value, &opt_out_threshold))
+    opt_out_threshold = 4;
   return opt_out_threshold;
 }
 
 base::TimeDelta PerHostBlackListDuration() {
   std::string param_value = ParamValue(kPerHostBlackListDurationInDays);
   int duration;
-  if (!base::StringToInt(param_value, &duration)) {
-    return base::TimeDelta::FromDays(30);
-  }
+  if (!base::StringToInt(param_value, &duration))
+    duration = 30;
   return base::TimeDelta::FromDays(duration);
 }
 
 base::TimeDelta HostIndifferentBlackListPerHostDuration() {
   std::string param_value = ParamValue(kHostIndifferentBlackListDurationInDays);
   int duration;
-  if (!base::StringToInt(param_value, &duration)) {
-    return base::TimeDelta::FromDays(365 * 100);
-  }
+  if (!base::StringToInt(param_value, &duration))
+    duration = 365 * 100;
   return base::TimeDelta::FromDays(duration);
 }
 
 base::TimeDelta SingleOptOutDuration() {
   std::string param_value = ParamValue(kSingleOptOutDurationInSeconds);
   int duration;
-  if (!base::StringToInt(param_value, &duration)) {
-    return base::TimeDelta::FromSeconds(60 * 5);
-  }
+  if (!base::StringToInt(param_value, &duration))
+    duration = 60 * 5;
   return base::TimeDelta::FromSeconds(duration);
 }
 
 base::TimeDelta OfflinePreviewFreshnessDuration() {
   std::string param_value = ParamValue(kOfflinePreviewFreshnessDurationInDays);
   int duration;
-  if (!base::StringToInt(param_value, &duration)) {
-    return base::TimeDelta::FromDays(7);
-  }
+  if (!base::StringToInt(param_value, &duration))
+    duration = 7;
   return base::TimeDelta::FromDays(duration);
 }
 
 }  // namespace params
 
 bool IsIncludedInClientSidePreviewsExperimentsFieldTrial() {
   // By convention, an experiment in the client-side previews study enables use
   // of at least one client-side previews optimization if its name begins with
   // "Enabled."
   return base::StartsWith(
@@ skipping 14 matching lines @@
 bool EnableOfflinePreviewsForTesting() {
   std::map<std::string, std::string> params;
   params[kOfflinePagesSlowNetwork] = kExperimentEnabled;
   return variations::AssociateVariationParams(kClientSidePreviewsFieldTrial,
                                               kEnabled, params) &&
          base::FieldTrialList::CreateFieldTrial(kClientSidePreviewsFieldTrial,
                                                 kEnabled);
 }
 
 }  // namespace previews