Misc. omnibox cleanup:

components/omnibox/browser/history_url_provider.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 "components/omnibox/browser/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 109 matching lines @@
   if ((score_buckets.relevance_cap() != -1) &&
       (undecayed_relevance >= score_buckets.relevance_cap()))
     return undecayed_relevance;
 
   // Time based decay using half-life time.
   double decayed_count = undecayed_count;
   double decay_factor = score_buckets.HalfLifeTimeDecay(time_since_last_visit);
   if (decayed_count > 0)
     decayed_count *= decay_factor;
 
-  const HUPScoringParams::ScoreBuckets::CountMaxRelevance* score_bucket = NULL;
+  const HUPScoringParams::ScoreBuckets::CountMaxRelevance* score_bucket =
+      nullptr;
   const double factor = (score_buckets.use_decay_factor() ?
       decay_factor : decayed_count);
   for (size_t i = 0; i < score_buckets.buckets().size(); ++i) {
     score_bucket = &score_buckets.buckets()[i];
     if (factor >= score_bucket->first)
       break;
   }
 
   return (score_bucket && (undecayed_relevance > score_bucket->second)) ?
       score_bucket->second : undecayed_relevance;
@@ skipping 286 matching lines @@
     const SearchTermsData& search_terms_data)
     : message_loop(base::MessageLoop::current()),
       input(input),
       prevent_inline_autocomplete(input.prevent_inline_autocomplete()),
       trim_http(trim_http),
       what_you_typed_match(what_you_typed_match),
       failed(false),
       exact_suggestion_is_in_history(false),
       promote_type(NEITHER),
       default_search_provider(default_search_provider ?
-          new TemplateURL(default_search_provider->data()) : NULL),
+          new TemplateURL(default_search_provider->data()) : nullptr),
       search_terms_data(new SearchTermsDataSnapshot(search_terms_data)) {
 }
 
 HistoryURLProviderParams::~HistoryURLProviderParams() {
 }
 
 HistoryURLProvider::HistoryURLProvider(AutocompleteProviderClient* client,
                                        AutocompleteProviderListener* listener)
     : HistoryProvider(AutocompleteProvider::TYPE_HISTORY_URL, client),
       listener_(listener),
-      params_(NULL),
+      params_(nullptr),
       search_url_database_(OmniboxFieldTrial::HUPSearchDatabase()) {
   // Initialize the default HUP scoring params.
   OmniboxFieldTrial::GetDefaultHUPScoringParams(&scoring_params_);
   // Initialize HUP scoring params based on the current experiment.
   OmniboxFieldTrial::GetExperimentalHUPScoringParams(&scoring_params_);
 }
 
 void HistoryURLProvider::Start(const AutocompleteInput& input,
                                bool minimal_changes) {
   TRACE_EVENT0("omnibox", "HistoryURLProvider::Start");
@@ skipping 40 matching lines @@
     matches_.push_back(what_you_typed_match);
 
   // We'll need the history service to run both passes, so try to obtain it.
   history::HistoryService* const history_service =
       client()->GetHistoryService();
   if (!history_service)
     return;
 
   // Get the default search provider and search terms data now since we have to
   // retrieve these on the UI thread, and the second pass runs on the history
-  // thread. |template_url_service| can be NULL when testing.
+  // thread. |template_url_service| can be null when testing.
   TemplateURLService* template_url_service = client()->GetTemplateURLService();
   TemplateURL* default_search_provider = template_url_service ?
-      template_url_service->GetDefaultSearchProvider() : NULL;
+      template_url_service->GetDefaultSearchProvider() : nullptr;
 
   // Create the data structure for the autocomplete passes.  We'll save this off
   // onto the |params_| member for later deletion below if we need to run pass
   // 2.
   std::unique_ptr<HistoryURLProviderParams> params(new HistoryURLProviderParams(
       fixed_up_input, trim_http, what_you_typed_match, default_search_provider,
       client()->GetSearchTermsData()));
   // Note that we use the non-fixed-up input here, since fixup may strip
   // trailing whitespace.
   params->prevent_inline_autocomplete = PreventInlineAutocomplete(input);
 
   // Pass 1: Get the in-memory URL database, and use it to find and promote
   // the inline autocomplete match, if any.
   history::URLDatabase* url_db = history_service->InMemoryDatabase();
-  // url_db can be NULL if it hasn't finished initializing (or failed to
-  // initialize).  In this case all we can do is fall back on the second
-  // pass.
+  // url_db can be null if it hasn't finished initializing (or failed to
+  // initialize).  In this case all we can do is fall back on the second pass.
   //
   // TODO(pkasting): We should just block here until this loads.  Any time
   // someone unloads the history backend, we'll get inconsistent inline
   // autocomplete behavior here.
   if (url_db) {
-    DoAutocomplete(NULL, url_db, params.get());
+    DoAutocomplete(nullptr, url_db, params.get());
     matches_.clear();
     PromoteMatchesIfNecessary(*params);
     // NOTE: We don't reset |params| here since at least the |promote_type|
     // field on it will be read by the second pass -- see comments in
     // DoAutocomplete().
   }
 
   // Pass 2: Ask the history service to call us back on the history thread,
   // where we can read the full on-disk DB.
   if (search_url_database_ && input.want_asynchronous_matches()) {
@@ skipping 49 matching lines @@
     // it's surprising and annoying.
 
     // Try to highlight "innermost" match location.  If we fix up "w" into
     // "www.w.com", we want to highlight the fifth character, not the first.
     // This relies on match.destination_url being the non-prefix-trimmed version
     // of match.contents.
     match.contents = display_string;
     const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(
         base::UTF8ToUTF16(destination_url.spec()), input.text());
     // It's possible for match.destination_url to not contain the user's input
-    // at all (so |best_prefix| is NULL), for example if the input is
+    // at all (so |best_prefix| is null), for example if the input is
     // "view-source:x" and |destination_url| has an inserted "http://" in the
     // middle.
-    if (best_prefix == NULL) {
+    if (!best_prefix) {
       AutocompleteMatch::ClassifyMatchInString(input.text(),
                                                match.contents,
                                                ACMatchClassification::URL,
                                                &match.contents_class);
     } else {
       AutocompleteMatch::ClassifyLocationInString(
           best_prefix->prefix.length() - offset, input.text().length(),
           match.contents.length(), ACMatchClassification::URL,
           &match.contents_class);
     }
   }
 
   return match;
 }
 
 void HistoryURLProvider::ExecuteWithDB(HistoryURLProviderParams* params,
                                        history::HistoryBackend* backend,
                                        history::URLDatabase* db) {
-  // We may get called with a NULL database if it couldn't be properly
+  // We may get called with a null database if it couldn't be properly
   // initialized.
   if (!db) {
     params->failed = true;
   } else if (!params->cancel_flag.IsSet()) {
     base::TimeTicks beginning_time = base::TimeTicks::Now();
 
     DoAutocomplete(backend, db, params);
 
     UMA_HISTOGRAM_TIMES("Autocomplete.HistoryAsyncQueryTime",
                         base::TimeTicks::Now() - beginning_time);
@@ skipping 202 matching lines @@
 
 void HistoryURLProvider::QueryComplete(
     HistoryURLProviderParams* params_gets_deleted) {
   TRACE_EVENT0("omnibox", "HistoryURLProvider::QueryComplete");
   // Ensure |params_gets_deleted| gets deleted on exit.
   std::unique_ptr<HistoryURLProviderParams> params(params_gets_deleted);
 
   // If the user hasn't already started another query, clear our member pointer
   // so we can't write into deleted memory.
   if (params_ == params_gets_deleted)
-    params_ = NULL;
+    params_ = nullptr;
 
   // Don't send responses for queries that have been canceled.
   if (params->cancel_flag.IsSet())
     return;  // Already set done_ when we canceled, no need to set it again.
 
   // Don't modify |matches_| if the query failed, since it might have a default
   // match in it, whereas |params->matches| will be empty.
   if (!params->failed) {
     matches_.clear();
     PromoteMatchesIfNecessary(*params);
@@ skipping 331 matching lines @@
     AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }