Cleanup, mostly replacing uses of SplitStringUsingSubstr() with SplitString(),

chrome/browser/prerender/prerender_field_trial.cc

 // Copyright (c) 2012 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/prerender/prerender_field_trial.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "components/variations/variations_associated_data.h"
 
 using base::FieldTrial;
 using base::FieldTrialList;
-using base::SplitStringUsingSubstr;
 using base::StringToInt;
 using std::string;
 using std::vector;
 
 namespace prerender {
 
 namespace {
 
 const char kOmniboxTrialName[] = "PrerenderFromOmnibox";
 int g_omnibox_trial_default_group_number = kint32min;
@@ skipping 214 matching lines @@
     const string switch_value =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kPrerenderFromOmnibox);
 
     if (switch_value == switches::kPrerenderFromOmniboxSwitchValueEnabled)
       return true;
 
     if (switch_value == switches::kPrerenderFromOmniboxSwitchValueDisabled)
       return false;
 
-    DCHECK(switch_value == switches::kPrerenderFromOmniboxSwitchValueAuto);
+    DCHECK_EQ(switches::kPrerenderFromOmniboxSwitchValueAuto, switch_value);
   }
 
   const int group = FieldTrialList::FindValue(kOmniboxTrialName);
   return group == FieldTrial::kNotFinalized ||
          group == g_omnibox_trial_default_group_number;
 }
 
 /*
 PrerenderLocalPredictorSpec is a field trial, and its value must have the
 following format:
 key1=value1:key2=value2:key3=value3
 eg "LocalPredictor=Enabled:SideEffectFreeWhitelist=Enabled"
 The function below extracts the value corresponding to a key provided from the
 LocalPredictorSpec.
 */
 string GetLocalPredictorSpecValue(string spec_key) {
   vector<string> elements;
-  SplitStringUsingSubstr(
-      FieldTrialList::FindFullName(kLocalPredictorSpecTrialName),
-      ":",
-      &elements);
+  base::SplitString(FieldTrialList::FindFullName(kLocalPredictorSpecTrialName),
+                    ':', &elements);
   for (int i = 0; i < static_cast<int>(elements.size()); i++) {
     vector<string> key_value;
-    SplitStringUsingSubstr(elements[i], "=", &key_value);
+    base::SplitString(elements[i], '=', &key_value);
     if (key_value.size() == 2 && key_value[0] == spec_key)
       return key_value[1];
   }
   return string();
 }
 
 bool IsUnencryptedSyncEnabled(Profile* profile) {
   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
       GetForProfile(profile);
   return service && service->GetOpenTabsUIDelegate() &&
       !service->EncryptEverythingEnabled();
 }
 
 // Indicates whether the Local Predictor is enabled based on field trial
 // selection.
 bool IsLocalPredictorEnabled() {
 #if defined(OS_ANDROID) || defined(OS_IOS)
   return false;
 #endif
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisablePrerenderLocalPredictor)) {
-    return false;
-  }
-  return GetLocalPredictorSpecValue(kLocalPredictorKeyName) == kEnabledGroup;
+  return
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisablePrerenderLocalPredictor) &&
+      GetLocalPredictorSpecValue(kLocalPredictorKeyName) == kEnabledGroup;
 }
 
 bool DisableLocalPredictorBasedOnSyncAndConfiguration(Profile* profile) {
   return
       GetLocalPredictorSpecValue(kLocalPredictorUnencryptedSyncOnlyKeyName) ==
-      kEnabledGroup &&
+          kEnabledGroup &&
       !IsUnencryptedSyncEnabled(profile);
 }
 
 bool IsLoggedInPredictorEnabled() {
   return IsLocalPredictorEnabled();
 }
 
 bool IsSideEffectFreeWhitelistEnabled() {
   return IsLocalPredictorEnabled() &&
       GetLocalPredictorSpecValue(kSideEffectFreeWhitelistKeyName) !=
@@ skipping 22 matching lines @@
 
 bool ShouldQueryPrerenderServiceForCandidateURLs() {
   return GetLocalPredictorSpecValue(
       kPrerenderQueryPrerenderServiceCandidateURLsKeyName) != kDisabledGroup;
 }
 
 string GetPrerenderServiceURLPrefix() {
   string prefix = chrome_variations::GetVariationParamValue(
       kLocalPredictorSpecTrialName,
       kPrerenderServiceURLPrefixParameterName);
-  if (prefix.empty())
-    prefix = kDefaultPrerenderServiceURLPrefix;
-  return prefix;
+  return prefix.empty() ? kDefaultPrerenderServiceURLPrefix : prefix;
 }
 
 int GetPrerenderServiceBehaviorID() {
   int id;
   StringToInt(GetLocalPredictorSpecValue(kPrerenderServiceBehaviorIDKeyName),
               &id);
   // The behavior ID must be non-negative.
-  if (id < 0)
-    id = 0;
-  return id;
+  return std::max(id, 0);
 }
 
 int GetPrerenderServiceFetchTimeoutMs() {
   int result;
   StringToInt(GetLocalPredictorSpecValue(kPrerenderServiceFetchTimeoutKeyName),
               &result);
-  // The behavior ID must be non-negative.
-  if (result < kMinPrerenderServiceTimeoutMs ||
-      result > kMaxPrerenderServiceTimeoutMs) {
-    result = kDefaultPrerenderServiceTimeoutMs;
-  }
-  return result;
+  // If the value is outside the valid range, use the default value.
+  return (result < kMinPrerenderServiceTimeoutMs ||
+          result > kMaxPrerenderServiceTimeoutMs) ?
+      kDefaultPrerenderServiceTimeoutMs : result;
 }
 
 int GetLocalPredictorTTLSeconds() {
   int ttl;
   StringToInt(GetLocalPredictorSpecValue(kPrerenderTTLKeyName), &ttl);
   // If the value is outside of 10s or 600s, use a default value of 180s.
-  if (ttl < 10 || ttl > 600)
-    ttl = 180;
-  return ttl;
+  return (ttl < 10 || ttl > 600) ? 180 : ttl;
 }
 
 int GetLocalPredictorPrerenderPriorityHalfLifeTimeSeconds() {
   int half_life_time;
   StringToInt(GetLocalPredictorSpecValue(kPrerenderPriorityHalfLifeTimeKeyName),
               &half_life_time);
   // Sanity check: Ensure the half life time is non-negative.
-  if (half_life_time < 0)
-    half_life_time = 0;
-  return half_life_time;
+  return std::max(half_life_time, 0);
 }
 
 int GetLocalPredictorMaxConcurrentPrerenders() {
   int num_prerenders;
   StringToInt(GetLocalPredictorSpecValue(kMaxConcurrentPrerenderKeyName),
               &num_prerenders);
-  // Sanity check: Ensure the number of prerenders is at least 1.
-  if (num_prerenders < 1)
-    num_prerenders = 1;
-  // Sanity check: Ensure the number of prerenders is at most 10.
-  if (num_prerenders > 10)
-    num_prerenders = 10;
-  return num_prerenders;
-};
+  // Sanity check: Ensure the number of prerenders is between 1 and 10.
+  return std::min(std::max(num_prerenders, 1), 10);
+}
 
 bool SkipLocalPredictorFragment() {
   return GetLocalPredictorSpecValue(kSkipFragment) == kEnabledGroup;
 }
 
 bool SkipLocalPredictorHTTPS() {
   return GetLocalPredictorSpecValue(kSkipHTTPS) == kEnabledGroup;
 }
 
 bool SkipLocalPredictorWhitelist() {
@@ skipping 21 matching lines @@
   return GetLocalPredictorSpecValue(kSkipPrerenderServiceCanadidates) ==
       kEnabledGroup;
 }
 
 bool ShouldMergeSessionStorageNamespaces() {
   return GetLocalPredictorSpecValue(kDisableSessionStorageNamespaceMerging) !=
       kDisabledGroup;
 }
 
 }  // namespace prerender