Code cleanup

chrome/browser/history/scored_history_match.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/history/scored_history_match.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <numeric>
@@ skipping 134 matching lines @@
     // makes it inlineable may be empty.
     DCHECK(best_inlineable_prefix != NULL);
     const int num_components_in_best_inlineable_prefix =
         best_inlineable_prefix->num_components;
     innermost_match = (num_components_in_best_inlineable_prefix ==
         num_components_in_best_prefix);
   }
 
   const float topicality_score = GetTopicalityScore(
       terms.size(), url, terms_to_word_starts_offsets, word_starts);
-  const float frecency_score = GetFrecency(
+  const float frequency_score = GetFrequency(
       now, (bookmark_service && bookmark_service->IsBookmarked(gurl)), visits);
-  raw_score_ = GetFinalRelevancyScore(topicality_score, frecency_score);
+  raw_score_ = GetFinalRelevancyScore(topicality_score, frequency_score);
   raw_score_ =
       (raw_score_ <= kint32max) ? static_cast<int>(raw_score_) : kint32max;
 
   if (also_do_hup_like_scoring_ && can_inline_) {
     // HistoryURL-provider-like scoring gives any match that is
     // capable of being inlined a certain minimum score.  Some of these
     // are given a higher score that lets them be shown in inline.
     // This test here derives from the test in
     // HistoryURLProvider::PromoteMatchForInlineAutocomplete().
     const bool promote_to_inline = (row.typed_count() > 1) ||
@@ skipping 344 matching lines @@
     }
     days_ago_to_recency_score_[days_ago] = unnormalized_recency_score / 100.0;
     if (days_ago > 0) {
       DCHECK_LE(days_ago_to_recency_score_[days_ago],
                 days_ago_to_recency_score_[days_ago - 1]);
     }
   }
 }
 
 // static
-float ScoredHistoryMatch::GetFrecency(const base::Time& now,
-                                      const bool bookmarked,
-                                      const VisitInfoVector& visits) {
+float ScoredHistoryMatch::GetFrequency(const base::Time& now,
+                                       const bool bookmarked,
+                                       const VisitInfoVector& visits) {
   // Compute the weighted average |value_of_transition| over the last at
   // most kMaxVisitsToScore visits, where each visit is weighted using
   // GetRecencyScore() based on how many days ago it happened.  Use
   // kMaxVisitsToScore as the denominator for the average regardless of
   // how many visits there were in order to penalize a match that has
   // fewer visits than kMaxVisitsToScore.
   float summed_visit_points = 0;
   for (size_t i = 0; i < std::min(visits.size(), kMaxVisitsToScore); ++i) {
     int value_of_transition =
         (visits[i].second == content::PAGE_TRANSITION_TYPED) ? 20 : 1;
     if (bookmarked)
       value_of_transition = std::max(value_of_transition, bookmark_value_);
     const float bucket_weight =
         GetRecencyScore((now - visits[i].first).InDays());
     summed_visit_points += (value_of_transition * bucket_weight);
   }
   return visits.size() * summed_visit_points / kMaxVisitsToScore;
 }
 
 // static
 float ScoredHistoryMatch::GetFinalRelevancyScore(float topicality_score,
-                                                 float frecency_score) {
+                                                 float frequency_score) {
   if (topicality_score == 0)
     return 0;
   // Here's how to interpret intermediate_score: Suppose the omnibox
   // has one input term.  Suppose we have a URL for which the omnibox
   // input term has a single URL hostname hit at a word boundary.  (This
   // implies topicality_score = 1.0.).  Then the intermediate_score for
-  // this URL will depend entirely on the frecency_score with
+  // this URL will depend entirely on the frequency_score with
   // this interpretation:
   // - a single typed visit more than three months ago, no other visits -> 0.2
   // - a visit every three days, no typed visits -> 0.706
   // - a visit every day, no typed visits -> 0.916
   // - a single typed visit yesterday, no other visits -> 2.0
   // - a typed visit once a week -> 11.77
   // - a typed visit every three days -> 14.12
   // - at least ten typed visits today -> 20.0 (maximum score)
-  const float intermediate_score = topicality_score * frecency_score;
+  const float intermediate_score = topicality_score * frequency_score;
   // The below code maps intermediate_score to the range [0, 1399].
   // The score maxes out at 1400 (i.e., cannot beat a good inline result).
   if (intermediate_score <= 1) {
     // Linearly extrapolate between 0 and 1.5 so 0 has a score of 400
     // and 1.5 has a score of 600.
     const float slope = (600 - 400) / (1.5f - 0.0f);
     return 400 + slope * intermediate_score;
   }
   if (intermediate_score <= 12.0) {
     // Linearly extrapolate up to 12 so 12 has a score of 1300.
@@ skipping 26 matching lines @@
     max_assigned_score_for_non_inlineable_matches_ =
         HistoryURLProvider::kScoreForBestInlineableResult - 1;
   }
   bookmark_value_ = OmniboxFieldTrial::HQPBookmarkValue();
   allow_tld_matches_ = OmniboxFieldTrial::HQPAllowMatchInTLDValue();
   allow_scheme_matches_ = OmniboxFieldTrial::HQPAllowMatchInSchemeValue();
   initialized_ = true;
 }
 
 }  // namespace history