[AiS] Reuse previous answer for verbatim.

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/base64.h"
@@ skipping 715 matching lines @@
 
   bool relevance_from_server;
   int verbatim_relevance = GetVerbatimRelevance(&relevance_from_server);
   int did_not_accept_default_suggestion =
       default_results_.suggest_results.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
   if (verbatim_relevance > 0) {
     const base::string16& trimmed_verbatim =
         base::CollapseWhitespace(input_.text(), false);
+
+    // Verbatim results don't get suggestions and hence, answers.

[Mark P, 2014/08/12 20:57:29]

This feels like the wrong place to do this.  By doing this so late in the game,
if you add logic mostly anywhere else in this class that depends on whether a
suggestion has an answer, it'd be wrong.

I suggest adding the answer information as soon as possible after the new
suggest reply is received.  I have an change that does some other processing
immediately after a reply is received; you can probably use the same structure
as soon as that goes in.

I'll point you to the changelist when I upload it.

[groby-ooo-7-16, 2014/08/12 22:09:20]

But I can't add it anywhere else - the answer needs to be attached to the
verbatim result, and that's only generated here.

In general, ConvertResultsToAutocompleteMatches() is where the old result gets
replaced with the new result - so that seems the right place. 

Can you point me to your other change so I can get a better idea?

[Mark P, 2014/08/12 23:17:43]

Good point.

[msw, 2014/08/13 19:01:04]

Why don't verbatim results get suggestions? Isn't that up to the provider?
If I paste in [weather los angeles], does that not get an answer either?

[Mark P, 2014/08/13 19:42:22]

I'll answer on behalf of groby@: the server does not return the verbatim match
as a suggestion, which means we don't get an answer for it.

The other question you asked is interesting.

+    // Scan previous matches if the last answer-bearing suggestion matches

[msw, 2014/08/13 19:01:04]

Why not just check |last_answer_seen_| instead of scanning?

[groby-ooo-7-16, 2014/08/13 20:07:17]

Because 
1) last_answer_seen_ is only the query text plus answer type, not the result
2) last_answer_seen_ going away for a cache of answers seen.

[Mark P, 2014/08/13 20:12:27]

If this is happening, can you add to the bug that's tracking the task (create a
cache of answers seen)
[create a bug if you don't have one already]
a note that once you have the cache you should revise this code to use the cache
and skip the scan.

[groby-ooo-7-16, 2014/08/13 23:39:21]

The cache still can't hold the answers content. The data is too volatile to keep
around for longer than a query. (I.e if I searched "goog stock" 30 minutes ago,
and re-search it again, I probably don't want to have a stock quote from 30
minutes ago)

Which means I need to track a timeout here, too. Let me add that :)

[Mark P, 2014/08/14 03:29:44]

When the user ceases to edit something in the omnibox (press escape, etc.),
SearchProvider clears all its stored information.  I'd argue that you should
_not_ put a timeout on top of that.  The amount of time the user spends editing
is fairly small, and if you think you want a timeout while editing is in
progress, I disagree--let's talk about it before you do it.

+    // verbatim, and if so, copy over answer contents.
+    base::string16 answer_contents;
+    base::string16 answer_type;
+    for (ACMatches::iterator it = matches_.begin(); it != matches_.end();
+         ++it) {
+      if (!it->answer_contents.empty() &&
+          it->fill_into_edit == trimmed_verbatim) {
+        answer_contents = it->answer_contents;
+        answer_type = it->answer_type;
+        break;
+      }
+    }
+
     SearchSuggestionParser::SuggestResult verbatim(
         trimmed_verbatim, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        trimmed_verbatim, base::string16(), base::string16(), base::string16(),
-        base::string16(), std::string(), std::string(), false,
-        verbatim_relevance, relevance_from_server, false,
-        trimmed_verbatim);
+        trimmed_verbatim, base::string16(), base::string16(), answer_contents,
+        answer_type, std::string(), std::string(), false, verbatim_relevance,
+        relevance_from_server, false, trimmed_verbatim);
     AddMatchToMap(verbatim, std::string(), did_not_accept_default_suggestion,
                   false, &map);
   }
   if (!keyword_input_.text().empty()) {
     const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
     // We only create the verbatim search query match for a keyword
     // if it's not an extension keyword.  Extension keywords are handled
     // in KeywordProvider::Start().  (Extensions are complicated...)
     // Note: in this provider, SEARCH_OTHER_ENGINE must correspond
     // to the keyword verbatim search query.  Do not create other matches
@@ skipping 510 matching lines @@
   last_answer_seen_.query_type = match->answer_type;
 }
 
 void SearchProvider::DoAnswersQuery(const AutocompleteInput& input) {
   // If the query text starts with trimmed input, this is valid prefetch data.
   prefetch_data_ = StartsWith(last_answer_seen_.full_query_text,
                               base::CollapseWhitespace(input.text(), false),
                               false) ?
       last_answer_seen_ : AnswersQueryData();
 }