Modified Omnibox extension api to use JSON Schema Compiler

chrome/browser/autocomplete/keyword_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/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
+namespace omnibox_api = extensions::api::omnibox;
+
 // Helper functor for Start(), for ending keyword mode unless explicitly told
 // otherwise.
 class KeywordProvider::ScopedEndExtensionKeywordMode {
  public:
   explicit ScopedEndExtensionKeywordMode(KeywordProvider* provider)
       : provider_(provider) { }
   ~ScopedEndExtensionKeywordMode() {
     if (provider_)
       provider_->MaybeEndExtensionKeywordMode();
   }
@@ skipping 511 matching lines @@
           model->GetTemplateURLForKeyword(keyword));
       extensions::ApplyDefaultSuggestionForExtensionKeyword(
           profile_, template_url,
           remaining_input,
           &matches_[0]);
       listener_->OnProviderUpdate(true);
       return;
     }
 
     case chrome::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY: {
-      const extensions::ExtensionOmniboxSuggestions& suggestions =
-        *content::Details<
-            extensions::ExtensionOmniboxSuggestions>(details).ptr();
+      const omnibox_api::SendSuggestions::Params& suggestions =
+          *content::Details<
+              omnibox_api::SendSuggestions::Params>(details).ptr();
       if (suggestions.request_id != current_input_id_)
         return;  // This is an old result. Just ignore.
 
       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 extensions::ExtensionOmniboxSuggestion& suggestion =
-            suggestions.suggestions[i];
+      for (size_t i = 0; i < suggestions.suggest_results.size(); ++i) {
+        const omnibox_api::SuggestResult& suggestion =
+            *suggestions.suggest_results[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)));
+            UTF8ToUTF16(suggestion.content), first_relevance - (i + 1)));
 
         AutocompleteMatch* match = &extension_suggest_matches_.back();
-        match->contents.assign(suggestion.description);
-        match->contents_class = suggestion.description_styles;
+        match->contents.assign(UTF8ToUTF16(suggestion.description));
+        match->contents_class =
+            extensions::StyleTypesToACMatchClassifications(suggestion);
         match->description.clear();
         match->description_class.clear();
       }
 
       done_ = true;
       matches_.insert(matches_.end(), extension_suggest_matches_.begin(),
                       extension_suggest_matches_.end());
       listener_->OnProviderUpdate(!extension_suggest_matches_.empty());
       return;
     }
@@ skipping 24 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     extensions::ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }