Omnibox SearchProvider Experiment Client Implementation.

chrome/browser/autocomplete/search_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 "chrome/browser/autocomplete/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 45 matching lines @@
       if (i.IsWord()) {
         if (found_word)
           return true;
         found_word = true;
       }
     }
   }
   return false;
 }
 
-};
+}  // namespace
 
 
 // SearchProvider::Providers --------------------------------------------------
 
 SearchProvider::Providers::Providers(TemplateURLService* template_url_service)
     : template_url_service_(template_url_service) {
 }
 
 const TemplateURL* SearchProvider::Providers::GetDefaultProviderURL() const {
   return default_provider_.empty() ? NULL :
@@ skipping 12 matching lines @@
 const int SearchProvider::kDefaultProviderURLFetcherID = 1;
 // static
 const int SearchProvider::kKeywordProviderURLFetcherID = 2;
 // static
 bool SearchProvider::query_suggest_immediately_ = false;
 
 SearchProvider::SearchProvider(ACProviderListener* listener, Profile* profile)
     : AutocompleteProvider(listener, profile, "Search"),
       providers_(TemplateURLServiceFactory::GetForProfile(profile)),
       suggest_results_pending_(0),
+      has_suggested_relevance_(false),
+      has_verbatim_relevance_(false),
+      verbatim_relevance_(0),
       have_suggest_results_(false),
       instant_finalized_(false) {
   // We use GetSuggestNumberOfGroups() as the group ID to mean "not in field
   // trial."  Field trial groups run from 0 to GetSuggestNumberOfGroups() - 1
   // (inclusive).
   int suggest_field_trial_group_number =
       AutocompleteFieldTrial::GetSuggestNumberOfGroups();
   if (AutocompleteFieldTrial::InSuggestFieldTrial()) {
     suggest_field_trial_group_number =
         AutocompleteFieldTrial::GetSuggestGroupNameAsNumber();
@@ skipping 192 matching lines @@
   if (suggest_results_pending_ == 0) {
     UpdateDone();
     // We only need to update the listener if we're actually done.
     if (done_)
       listener_->OnProviderUpdate(false);
   }
 }
 
 void SearchProvider::Stop() {
   StopSuggest();
-  ClearResults();
   done_ = true;
   default_provider_suggest_text_.clear();
 }
 
 void SearchProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
   provider_info->push_back(metrics::OmniboxEventProto_ProviderInfo());
   metrics::OmniboxEventProto_ProviderInfo& new_entry = provider_info->back();
   new_entry.set_provider(AsOmniboxEventProviderType());
   new_entry.set_provider_done(done_);
 }
@@ skipping 112 matching lines @@
   // have its results, or are allowed to keep running it, just do that, rather
   // than starting a new query.
   if (minimal_changes &&
       (have_suggest_results_ ||
        (!done_ &&
         input_.matches_requested() == AutocompleteInput::ALL_MATCHES)))
     return;
 
   // We can't keep running any previous query, so halt it.
   StopSuggest();
-  ClearResults();
+
+  // Remove existing results that cannot inline autocomplete the new input.
+  RemoveStaleResults();
 
   // We can't start a new query if we're only allowed synchronous results.
   if (input_.matches_requested() != AutocompleteInput::ALL_MATCHES)
     return;
 
   // We'll have at least one pending fetch. Set it to 1 now, but the value is
   // correctly set in Run. As Run isn't invoked immediately we need to set this
   // now, else we won't think we're waiting on results from the server when we
   // really are.
   suggest_results_pending_ = 1;
@@ skipping 66 matching lines @@
   // Stop any in-progress URL fetches.
   keyword_fetcher_.reset();
   default_fetcher_.reset();
 }
 
 void SearchProvider::ClearResults() {
   keyword_suggest_results_.clear();
   default_suggest_results_.clear();
   keyword_navigation_results_.clear();
   default_navigation_results_.clear();
+  has_suggested_relevance_ = false;
+  has_verbatim_relevance_ = false;
+  verbatim_relevance_ = 0;
   have_suggest_results_ = false;
 }
 
+void SearchProvider::RemoveStaleResults() {
+  RemoveStaleSuggestResults(&keyword_suggest_results_, true);
+  RemoveStaleSuggestResults(&default_suggest_results_, false);
+  RemoveStaleNavigationResults(&keyword_navigation_results_, true);
+  RemoveStaleNavigationResults(&default_navigation_results_, false);
+}
+
+void SearchProvider::RemoveStaleSuggestResults(SuggestResults* list,
+                                               bool is_keyword) {
+  const string16& input = is_keyword ? keyword_input_text_ : input_.text();
+  for (SuggestResults::iterator i = list->begin(); i < list->end();)
+    i = (i->suggestion().find(input) != 0) ? list->erase(i) : (i + 1);

[Peter Kasting, 2012/06/05 00:47:51]

Nit: Seems clearer:

  i = StartsWith(i->suggestion(), input, false) ? (i + 1) : list->erase(i);

Note that passing "false" here does case-insensitive comparison... I think
that's probably what you want (though you should check with the suggest guys).

BestURLPrefix() should also do case-insensitive comparisons, I think, which
should address the similar problem below.

You may also want to remove the "!" in RemoveStaleNavigationResults() and
reverse the conditional so the orders in the two functions still match.

[msw, 2012/06/05 01:49:41]

Done.

+}
+
+void SearchProvider::RemoveStaleNavigationResults(NavigationResults* list,
+                                                  bool is_keyword) {
+  const string16& input = is_keyword ? keyword_input_text_ : input_.text();
+  for (NavigationResults::iterator i = list->begin(); i < list->end();) {
+    const string16 fill(AutocompleteInput::FormattedStringWithEquivalentMeaning(
+        i->url(), StringForURLDisplay(i->url(), true, false)));
+    i = !URLPrefix::BestURLPrefix(fill, input) ? list->erase(i) : (i + 1);
+  }
+}
+
+void SearchProvider::ApplyCalculatedRelevance() {
+  ApplyCalculatedSuggestRelevance(&keyword_suggest_results_, true);
+  ApplyCalculatedSuggestRelevance(&default_suggest_results_, false);
+  ApplyCalculatedNavigationRelevance(&keyword_navigation_results_, true);
+  ApplyCalculatedNavigationRelevance(&default_navigation_results_, false);
+  has_suggested_relevance_ = false;
+  has_verbatim_relevance_ = false;
+  verbatim_relevance_ = 0;
+}
+
+void SearchProvider::ApplyCalculatedSuggestRelevance(SuggestResults* list,
+                                                     bool is_keyword) {
+  for (size_t i = 0; i < list->size(); ++i) {
+    (*list)[i].set_relevance(CalculateRelevanceForSuggestion(is_keyword) +
+                             (list->size() - i - 1));
+  }
+}
+
+void SearchProvider::ApplyCalculatedNavigationRelevance(NavigationResults* list,
+                                                        bool is_keyword) {
+  for (size_t i = 0; i < list->size(); ++i) {
+    (*list)[i].set_relevance(CalculateRelevanceForNavigation(is_keyword) +
+                             (list->size() - i - 1));
+  }
+}
+
 net::URLFetcher* SearchProvider::CreateSuggestFetcher(
     int id,
     const TemplateURLRef& suggestions_url,
     const string16& text) {
   DCHECK(suggestions_url.SupportsReplacement());
   net::URLFetcher* fetcher = content::URLFetcher::Create(id,
       GURL(suggestions_url.ReplaceSearchTerms(text,
           TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())),
       net::URLFetcher::GET, this);
   fetcher->SetRequestContext(profile_->GetRequestContext());
@@ skipping 13 matching lines @@
   if (!root_val->GetAsList(&root_list) || !root_list->GetString(0, &query) ||
       (query != input_text) || !root_list->GetList(1, &results))
     return false;
 
   // 3rd element: Description list.
   ListValue* descriptions = NULL;
   root_list->GetList(2, &descriptions);
 
   // 4th element: Disregard the query URL list for now.
 
+  // Reset suggested relevance information from the default provider.
+  if (!is_keyword) {
+    has_suggested_relevance_ = false;
+    has_verbatim_relevance_ = false;
+    verbatim_relevance_ = 0;
+  }
+
   // 5th element: Optional key-value pairs from the Suggest server.
   ListValue* types = NULL;
-  DictionaryValue* dict_val = NULL;
-  if (root_list->GetDictionary(4, &dict_val)) {
-    // Parse Google Suggest specific type extension.
-    dict_val->GetList("google:suggesttype", &types);
+  ListValue* relevances = NULL;
+  DictionaryValue* extras = NULL;
+  if (root_list->GetDictionary(4, &extras)) {
+    extras->GetList("google:suggesttype", &types);
+
+    // Only accept relevance suggestions if Instant is disabled.
+    if (!is_keyword && !InstantController::IsEnabled(profile_)) {
+      // Discard this list if its size does not match that of the suggestions.
+      if (extras->GetList("google:suggestrelevance", &relevances) &&
+          relevances->GetSize() != results->GetSize())
+        relevances = NULL;
+
+      if (extras->GetInteger("google:verbatimrelevance", &verbatim_relevance_))
+        has_verbatim_relevance_ = true;
+    }
   }
 
   SuggestResults* suggest_results =
       is_keyword ? &keyword_suggest_results_ : &default_suggest_results_;
   NavigationResults* navigation_results =
       is_keyword ? &keyword_navigation_results_ : &default_navigation_results_;
 
-  string16 result;
-  bool results_updated = false;
+  // Clear the previous results now that new results are available.
+  suggest_results->clear();
+  navigation_results->clear();
+
+  string16 result, title;
+  std::string type;
+  int relevance = -1;
   for (size_t index = 0; results->GetString(index, &result); ++index) {
     // Google search may return empty suggestions for weird input characters,
     // they make no sense at all and can cause problems in our code.
     if (result.empty())
       continue;
 
-    std::string type;
+    // Apply valid suggested relevance scores; discard invalid lists.
+    if (relevances != NULL && !relevances->GetInteger(index, &relevance))
+      relevances = NULL;
     if (types && types->GetString(index, &type) && (type == "NAVIGATION")) {
-      if (navigation_results->size() < kMaxMatches) {
-        // Do not blindly trust the URL coming from the server to be valid.
-        GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(result), std::string()));
-        if (url.is_valid()) {
-          string16 description;
-          if (descriptions != NULL)
-            descriptions->GetString(index, &description);
-          // Decrement the relevance for successive results to preserve order.
-          int relevance = CalculateRelevanceForNavigation(is_keyword) +
-                          (kMaxMatches - navigation_results->size() - 1);
-          navigation_results->push_back(
-              NavigationResult(url, description, relevance));
-          results_updated = true;
-        }
+      // Do not blindly trust the URL coming from the server to be valid.
+      GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(result), std::string()));
+      if (url.is_valid()) {
+        if (descriptions != NULL)
+          descriptions->GetString(index, &title);
+        navigation_results->push_back(NavigationResult(url, title, relevance));
       }
     } else {
-      // TODO(kochi): Currently we treat a calculator result as a query, but it
-      // is better to have better presentation for caluculator results.
-      if (suggest_results->size() < kMaxMatches) {
-        // Decrement the relevance for successive results to preserve order.
-        int relevance = CalculateRelevanceForSuggestion(is_keyword) +
-                        (kMaxMatches - suggest_results->size() - 1);
-        suggest_results->push_back(SuggestResult(result, relevance));
-        results_updated = true;
-      }
+      // TODO(kochi): Improve calculator result presentation.
+      suggest_results->push_back(SuggestResult(result, relevance));
     }
   }
 
+  // Apply calculated relevance scores if a valid list was not provided.
+  if (relevances == NULL) {
+    ApplyCalculatedSuggestRelevance(suggest_results, is_keyword);
+    ApplyCalculatedNavigationRelevance(navigation_results, is_keyword);
+  } else if (!is_keyword) {
+    has_suggested_relevance_ = true;
+  }
+
   have_suggest_results_ = true;
-  return results_updated;
+  return true;

[Peter Kasting, 2012/06/05 00:47:51]

Nit: Did you want to preserve the more fine-grained tracking you previously had?
 It seems like it'd work OK as long as we also added in a "results_updated |=
(!suggest_results.empty() || !navigation_results.empty());" before clearing
those lists.

[msw, 2012/06/05 01:49:41]

I'll leave this as-is. Getting the exact same results would also trigger a
results_updated 'false positive'. The only downside here seems to be a (minor?)
perf penalty. I think code simplicity is more important for now.

 }
 
 void SearchProvider::ConvertResultsToAutocompleteMatches() {
   // Convert all the results to matches and add them to a map, so we can keep
   // the most relevant match for each result.
   MatchMap map;
   const Time no_time;
   int did_not_accept_keyword_suggestion = keyword_suggest_results_.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
   // Keyword what you typed results are handled by the KeywordProvider.
 
   int verbatim_relevance = CalculateRelevanceForWhatYouTyped();
   int did_not_accept_default_suggestion = default_suggest_results_.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
-  AddMatchToMap(input_.text(), input_.text(), verbatim_relevance,
-                AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
-                did_not_accept_default_suggestion, false, &map);
+  if (verbatim_relevance > 0) {
+    AddMatchToMap(input_.text(), input_.text(), verbatim_relevance,
+                  AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
+                  did_not_accept_default_suggestion, false, &map);
+  }
   const size_t what_you_typed_size = map.size();
   if (!default_provider_suggest_text_.empty()) {
     AddMatchToMap(input_.text() + default_provider_suggest_text_,
                   input_.text(), verbatim_relevance + 1,
                   AutocompleteMatch::SEARCH_SUGGEST,
                   did_not_accept_default_suggestion, false, &map);
   }
 
   AddHistoryResultsToMap(keyword_history_results_, true,
                          did_not_accept_keyword_suggestion, &map);
@@ skipping 12 matching lines @@
   AddNavigationResultsToMatches(default_navigation_results_, false);
 
   // Allow an additional match for "what you typed" if it's present.
   const size_t max_total_matches = kMaxMatches + what_you_typed_size;
   std::partial_sort(matches_.begin(),
       matches_.begin() + std::min(max_total_matches, matches_.size()),
       matches_.end(), &AutocompleteMatch::MoreRelevant);
   if (matches_.size() > max_total_matches)
     matches_.erase(matches_.begin() + max_total_matches, matches_.end());
 
+  // The top result must be inlinable; apply calculated scores if it is not.
+  if (!matches_.empty() &&
+      (has_suggested_relevance_ || has_verbatim_relevance_) &&
+      (matches_.front().type == AutocompleteMatch::SEARCH_SUGGEST ||
+       matches_.front().type == AutocompleteMatch::NAVSUGGEST) &&
+      matches_.front().inline_autocomplete_offset == string16::npos) {
+    ApplyCalculatedRelevance();
+    ConvertResultsToAutocompleteMatches();
+  }
+
   UpdateStarredStateOfMatches();
   UpdateDone();
 }
 
 void SearchProvider::AddNavigationResultsToMatches(
     const NavigationResults& navigation_results,
     bool is_keyword) {
   if (!navigation_results.empty()) {
     // TODO(kochi|msw): Add more navigational results if they get more
     //                  meaningful relevance values; see http://b/1170574.
@@ skipping 108 matching lines @@
                                             bool is_keyword,
                                             MatchMap* map) {
   const string16& input_text = is_keyword ? keyword_input_text_ : input_.text();
   for (size_t i = 0; i < results.size(); ++i) {
     AddMatchToMap(results[i].suggestion(), input_text, results[i].relevance(),
                   AutocompleteMatch::SEARCH_SUGGEST, i, is_keyword, map);
   }
 }
 
 int SearchProvider::CalculateRelevanceForWhatYouTyped() const {
+  if (has_verbatim_relevance_ && !input_.prevent_inline_autocomplete())
+    return verbatim_relevance_;
+
   if (!providers_.keyword_provider().empty())
     return 250;
 
   switch (input_.type()) {
     case AutocompleteInput::UNKNOWN:
     case AutocompleteInput::QUERY:
     case AutocompleteInput::FORCED_QUERY:
       return 1300;
 
     case AutocompleteInput::REQUESTED_URL:
@@ skipping 215 matching lines @@
       ACMatchClassification::NONE, &match.description_class);
   return match;
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when there are no more suggest queries pending (this is set to 1
   // when the timer is started) and we're not waiting on instant.
   done_ = ((suggest_results_pending_ == 0) &&
            (instant_finalized_ || !InstantController::IsEnabled(profile_)));
 }