No chrome dependencies in KeywordProvider

chrome/browser/autocomplete/keyword_extensions_delegate_impl.cc

 // Copyright 2014 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_extensions_delegate_impl.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 
 namespace omnibox_api = extensions::api::omnibox;
 
 int KeywordExtensionsDelegateImpl::global_input_uid_ = 0;
 
 KeywordExtensionsDelegateImpl::KeywordExtensionsDelegateImpl(
+    Profile* profile,
     KeywordProvider* provider)
     : KeywordExtensionsDelegate(provider),
+      profile_(profile),
       provider_(provider) {
   DCHECK(provider_);
 
   current_input_id_ = 0;
   // Extension suggestions always come from the original profile, since that's
   // where extensions run. We use the input ID to distinguish whether the
   // suggestions are meant for us.
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY,
-                 content::Source<Profile>(profile()->GetOriginalProfile()));
+                 content::Source<Profile>(profile_->GetOriginalProfile()));
   registrar_.Add(
       this,
       extensions::NOTIFICATION_EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED,
-      content::Source<Profile>(profile()->GetOriginalProfile()));
+      content::Source<Profile>(profile_->GetOriginalProfile()));
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_OMNIBOX_INPUT_ENTERED,
-                 content::Source<Profile>(profile()));
+                 content::Source<Profile>(profile_));
 }
 
 KeywordExtensionsDelegateImpl::~KeywordExtensionsDelegateImpl() {
 }
 
 void  KeywordExtensionsDelegateImpl::IncrementInputId() {
   current_input_id_ = ++global_input_uid_;
 }
 
 bool KeywordExtensionsDelegateImpl::IsEnabledExtension(
-    Profile* profile,
     const std::string& extension_id) {
   ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
   const extensions::Extension* extension =
       extension_service->GetExtensionById(extension_id, false);
   return extension &&
-      (!profile->IsOffTheRecord() ||
-       !extensions::util::IsIncognitoEnabled(extension_id, profile));
+      (!profile_->IsOffTheRecord() ||
+       !extensions::util::IsIncognitoEnabled(extension_id, profile_));
 }
 
 bool KeywordExtensionsDelegateImpl::Start(
     const AutocompleteInput& input,
     bool minimal_changes,
     const TemplateURL* template_url,
     const base::string16& remaining_input) {
   DCHECK(template_url);
 
   if (input.want_asynchronous_matches()) {
     std::string extension_id = template_url->GetExtensionId();
     if (extension_id != current_keyword_extension_id_)
       MaybeEndExtensionKeywordMode();
     if (current_keyword_extension_id_.empty())
       EnterExtensionKeywordMode(extension_id);
   }
 
   extensions::ApplyDefaultSuggestionForExtensionKeyword(
-      profile(), template_url, remaining_input, &matches()->front());
+      profile_, template_url, remaining_input, &matches()->front());
 
   if (minimal_changes) {
     // If the input hasn't significantly changed, we can just use the
     // suggestions from last time. We need to readjust the relevance to
     // ensure it is less than the main match's relevance.
     for (size_t i = 0; i < extension_suggest_matches_.size(); ++i) {
       matches()->push_back(extension_suggest_matches_[i]);
       matches()->back().relevance = matches()->front().relevance - (i + 1);
     }
   } else if (input.want_asynchronous_matches()) {
     extension_suggest_last_input_ = input;
     extension_suggest_matches_.clear();
 
     // We only have to wait for suggest results if there are actually
     // extensions listening for input changes.
     if (extensions::ExtensionOmniboxEventRouter::OnInputChanged(
-            profile(), template_url->GetExtensionId(),
+            profile_, template_url->GetExtensionId(),
             base::UTF16ToUTF8(remaining_input), current_input_id_))
       set_done(false);
   }
   return input.want_asynchronous_matches();
 }
 
 void KeywordExtensionsDelegateImpl::EnterExtensionKeywordMode(
     const std::string& extension_id) {
   DCHECK(current_keyword_extension_id_.empty());
   current_keyword_extension_id_ = extension_id;
 
   extensions::ExtensionOmniboxEventRouter::OnInputStarted(
-      profile(), current_keyword_extension_id_);
+      profile_, current_keyword_extension_id_);
 }
 
 void KeywordExtensionsDelegateImpl::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     extensions::ExtensionOmniboxEventRouter::OnInputCancelled(
-        profile(), current_keyword_extension_id_);
+        profile_, current_keyword_extension_id_);
     current_keyword_extension_id_.clear();
   }
 }
 
 void KeywordExtensionsDelegateImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   TemplateURLService* model = provider_->GetTemplateURLService();
   const AutocompleteInput& input = extension_suggest_last_input_;
@@ skipping 13 matching lines @@
       // session.
       base::string16 keyword, remaining_input;
       if (matches()->empty() || current_keyword_extension_id_.empty() ||
           !KeywordProvider::ExtractKeywordFromInput(
               input, &keyword, &remaining_input))
         return;
 
       const TemplateURL* template_url(
           model->GetTemplateURLForKeyword(keyword));
       extensions::ApplyDefaultSuggestionForExtensionKeyword(
-          profile(), template_url, remaining_input, &matches()->front());
+          profile_, template_url, remaining_input, &matches()->front());
       OnProviderUpdate(true);
       return;
     }
 
     case extensions::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY: {
       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.
@@ skipping 44 matching lines @@
 
     default:
       NOTREACHED();
       return;
   }
 }
 
 void KeywordExtensionsDelegateImpl::OnProviderUpdate(bool updated_matches) {
   provider_->listener_->OnProviderUpdate(updated_matches);
 }