Strip special characters in extension omnibox suggestions.

chrome/browser/autocomplete/keyword_provider.cc

 // Copyright (c) 2011 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/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/string16.h"
@@ skipping 422 matching lines @@
   // into keyword templates.
   FillInURLAndContents(profile_, remaining_input, element, &result);
 
   if (supports_replacement)
     result.template_url = element;
   result.transition = content::PAGE_TRANSITION_KEYWORD;
 
   return result;
 }
 
+AutocompleteMatch KeywordProvider::CreateAutocompleteMatchFromSuggestion(
+    TemplateURLService* model,
+    const string16& keyword,
+    const AutocompleteInput& input,
+    const ExtensionOmniboxSuggestion& suggestion,
+    int relevance) {
+  AutocompleteMatch match = CreateAutocompleteMatch(
+      model, keyword, input, keyword.length(),
+      suggestion.content, relevance);
+  match.contents = AutocompleteMatch::SanitizeString(suggestion.description);

[Peter Kasting, 2011/10/26 01:07:22]

We can't sanitize the string and not update the description styles to match. 
This is what I was worried about happening if we made the sanitization a member
function on AutocompleteMatch but I guess making it static didn't prevent the
problem.  We may want to do this work in the ExtensionOmniboxSuggestion class
instead.

+  match.contents_class = suggestion.description_styles;
+  match.description.clear();
+  match.description_class.clear();
+  return match;
+}
+
 void KeywordProvider::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   TemplateURLService* model =
       profile_ ? TemplateURLServiceFactory::GetForProfile(profile_) : model_;
   const AutocompleteInput& input = extension_suggest_last_input_;
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_OMNIBOX_INPUT_ENTERED:
       // Input has been accepted, so we're done with this input session. Ensure
@@ skipping 28 matching lines @@
 
       string16 keyword, remaining_input;
       if (!ExtractKeywordFromInput(input, &keyword, &remaining_input)) {
         NOTREACHED();
         return;
       }
 
       // TODO(mpcomplete): consider clamping the number of suggestions to
       // AutocompleteProvider::kMaxMatches.
       for (size_t i = 0; i < suggestions.suggestions.size(); ++i) {
-        const ExtensionOmniboxSuggestion& suggestion =
-            suggestions.suggestions[i];
         // We want to order these suggestions in descending order, so start with
         // the relevance of the first result (added synchronously in Start()),
         // and subtract 1 for each subsequent suggestion from the extension.
         // We know that |complete| is true, because we wouldn't get results from
         // the extension unless the full keyword had been typed.
         int first_relevance = CalculateRelevance(input.type(), true, true,
             input.prefer_keyword(), input.allow_exact_keyword_match());
-        extension_suggest_matches_.push_back(CreateAutocompleteMatch(
-            model, keyword, input, keyword.length(),
-            suggestion.content, first_relevance - (i + 1)));
-
-        AutocompleteMatch* match = &extension_suggest_matches_.back();
-        match->contents.assign(suggestion.description);
-        match->contents_class = suggestion.description_styles;
-        match->description.clear();
-        match->description_class.clear();
+        int relevance = first_relevance - (i + 1);
+        extension_suggest_matches_.push_back(
+            CreateAutocompleteMatchFromSuggestion(model,
+                                                  keyword,
+                                                  input,
+                                                  suggestions.suggestions[i],
+                                                  relevance));
       }
 
       done_ = true;
       matches_.insert(matches_.end(), extension_suggest_matches_.begin(),
                       extension_suggest_matches_.end());
       listener_->OnProviderUpdate(!extension_suggest_matches_.empty());
       return;
     }
 
     default:
@@ skipping 12 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }