No chrome dependencies in KeywordProvider

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/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/keyword_extensions_delegate.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_match.h"
 #include "components/omnibox/autocomplete_provider_listener.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
-#include "extensions/browser/extension_system.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
-#if defined(ENABLE_EXTENSIONS)
-#include "chrome/browser/autocomplete/keyword_extensions_delegate_impl.h"
-#endif
-
 namespace {
 
 // Helper functor for Start(), for sorting keyword matches by quality.
 class CompareQuality {
  public:
   // A keyword is of higher quality when a greater fraction of it has been
   // typed, that is, when it is shorter.
   //
   // TODO(pkasting): Most recent and most frequent keywords are probably
   // better rankings than the fraction of the keyword typed.  We should
@@ skipping 28 matching lines @@
   if (delegate_)
     delegate_->MaybeEndExtensionKeywordMode();
 }
 
 void ScopedEndExtensionKeywordMode::StayInKeywordMode() {
   delegate_ = NULL;
 }
 
 }  // namespace
 
-KeywordProvider::KeywordProvider(AutocompleteProviderListener* listener,
-                                 Profile* profile)
+KeywordProvider::KeywordProvider(
+    AutocompleteProviderListener* listener,
+    TemplateURLService* model)
     : AutocompleteProvider(AutocompleteProvider::TYPE_KEYWORD),
       listener_(listener),
-      profile_(profile),
-      model_(NULL) {
-#if defined(ENABLE_EXTENSIONS)
-  extensions_delegate_.reset(new KeywordExtensionsDelegateImpl(this));
-#endif
-}
-
-KeywordProvider::KeywordProvider(AutocompleteProviderListener* listener,
-                                 TemplateURLService* model)
-    : AutocompleteProvider(AutocompleteProvider::TYPE_KEYWORD),
-      listener_(listener),
-      profile_(NULL),
       model_(model) {
 }
 
 // static
 base::string16 KeywordProvider::SplitKeywordFromInput(
     const base::string16& input,
     bool trim_leading_whitespace,
     base::string16* remaining_input) {
   // Find end of first token.  The AutocompleteController has trimmed leading
   // whitespace, so we need not skip over that.
@@ skipping 88 matching lines @@
   // Don't provide a keyword if it doesn't support replacement.
   const TemplateURL* const template_url =
       url_service->GetTemplateURLForKeyword(keyword);
   if (!template_url ||
       !template_url->SupportsReplacement(url_service->search_terms_data()))
     return base::string16();
 
   // Don't provide a keyword for inactive/disabled extension keywords.
   if ((template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION) &&
       extensions_delegate_ &&
-      !extensions_delegate_->IsEnabledExtension(
-          profile_, template_url->GetExtensionId()))
+      !extensions_delegate_->IsEnabledExtension(template_url->GetExtensionId()))
     return base::string16();
 
   return keyword;
 }
 
 AutocompleteMatch KeywordProvider::CreateVerbatimMatch(
     const base::string16& text,
     const base::string16& keyword,
     const AutocompleteInput& input) {
   // A verbatim match is allowed to be the default match.
@@ skipping 45 matching lines @@
   TemplateURLService::TemplateURLVector matches;
   GetTemplateURLService()->FindMatchingKeywords(
       keyword, !remaining_input.empty(), &matches);
 
   for (TemplateURLService::TemplateURLVector::iterator i(matches.begin());
        i != matches.end(); ) {
     const TemplateURL* template_url = *i;
 
     // Prune any extension keywords that are disallowed in incognito mode (if
     // we're incognito), or disabled.
-    if (profile_ &&
-        (template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION) &&
+    if (template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION &&
         extensions_delegate_ &&
         !extensions_delegate_->IsEnabledExtension(
-            profile_, template_url->GetExtensionId())) {
+            template_url->GetExtensionId())) {
       i = matches.erase(i);
       continue;
     }
 
     // Prune any substituting keywords if there is no substitution.
     if (template_url->SupportsReplacement(
             GetTemplateURLService()->search_terms_data()) &&
         remaining_input.empty() &&
         !input.allow_exact_keyword_match()) {
       i = matches.erase(i);
@@ skipping 25 matching lines @@
 
     // TODO(pkasting): We should probably check that if the user explicitly
     // typed a scheme, that scheme matches the one in |template_url|.
 
     // When creating an exact match (either for the keyword itself, no
     // remaining query or an extension keyword, possibly with remaining
     // input), allow the match to be the default match.
     matches_.push_back(CreateAutocompleteMatch(
         template_url, input, keyword.length(), remaining_input, true, -1));
 
-    if (profile_ && is_extension_keyword && extensions_delegate_) {
+    if (is_extension_keyword && extensions_delegate_) {
       if (extensions_delegate_->Start(input, minimal_changes, template_url,
                                       remaining_input))
         keyword_mode_toggle.StayInKeywordMode();
     }
   } else {
     if (matches.size() > kMaxMatches)
       matches.erase(matches.begin() + kMaxMatches, matches.end());
     for (TemplateURLService::TemplateURLVector::const_iterator i(
          matches.begin()); i != matches.end(); ++i) {
       matches_.push_back(CreateAutocompleteMatch(
@@ skipping 146 matching lines @@
                                                       remaining_input,
                                                       &content_param_offsets));
     DCHECK_EQ(2U, content_param_offsets.size());
     AutocompleteMatch::ClassifyLocationInString(content_param_offsets[1],
         remaining_input.length(), match->contents.length(),
         ACMatchClassification::NONE, &match->contents_class);
   }
 }
 
 TemplateURLService* KeywordProvider::GetTemplateURLService() const {
-  TemplateURLService* service = profile_ ?
-      TemplateURLServiceFactory::GetForProfile(profile_) : model_;
   // Make sure the model is loaded. This is cheap and quickly bails out if
   // the model is already loaded.
-  DCHECK(service);
-  service->Load();
-  return service;
+  model_->Load();
+  return model_;
 }