Remove ExtensionService::extension_prefs()

chrome/browser/extensions/api/omnibox/omnibox_api.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/extensions/api/omnibox/omnibox_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/tab_helper.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/extensions/api/omnibox.h"
 #include "chrome/common/extensions/api/omnibox/omnibox_handler.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_prefs_factory.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "ui/gfx/image/image.h"
 
 namespace extensions {
 
 namespace omnibox = api::omnibox;
 namespace SendSuggestions = omnibox::SendSuggestions;
@@ skipping 16 matching lines @@
 static const int kOmniboxIconPaddingLeft = 0;
 static const int kOmniboxIconPaddingRight = 2;
 #else
 static const int kOmniboxIconPaddingLeft = 0;
 static const int kOmniboxIconPaddingRight = 0;
 #endif
 
 scoped_ptr<omnibox::SuggestResult> GetOmniboxDefaultSuggestion(
     Profile* profile,
     const std::string& extension_id) {
-  ExtensionPrefs* prefs =
-      ExtensionSystem::Get(profile)->extension_service()->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
 
   scoped_ptr<omnibox::SuggestResult> suggestion;
   const base::DictionaryValue* dict = NULL;
   if (prefs && prefs->ReadPrefAsDictionary(extension_id,
                                            kOmniboxDefaultSuggestion,
                                            &dict)) {
     suggestion.reset(new omnibox::SuggestResult);
     omnibox::SuggestResult::Populate(*dict, suggestion.get());
   }
   return suggestion.Pass();
 }
 
 // Tries to set the omnibox default suggestion; returns true on success or
 // false on failure.
 bool SetOmniboxDefaultSuggestion(
     Profile* profile,
     const std::string& extension_id,
     const omnibox::DefaultSuggestResult& suggestion) {
-  ExtensionPrefs* prefs =
-      ExtensionSystem::Get(profile)->extension_service()->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
   if (!prefs)
     return false;
 
   scoped_ptr<base::DictionaryValue> dict = suggestion.ToValue();
   // Add the content field so that the dictionary can be used to populate an
   // omnibox::SuggestResult.
   dict->SetWithoutPathExpansion(kSuggestionContent, new base::StringValue(""));
   prefs->UpdateExtensionPref(extension_id,
                              kOmniboxDefaultSuggestion,
                              dict.release());
@@ skipping 11 matching lines @@
       make_scoped_ptr(new base::ListValue())));
   event->restrict_to_browser_context = profile;
   ExtensionSystem::Get(profile)->event_router()->
       DispatchEventToExtension(extension_id, event.Pass());
 }
 
 // static
 bool ExtensionOmniboxEventRouter::OnInputChanged(
     Profile* profile, const std::string& extension_id,
     const std::string& input, int suggest_id) {
-  if (!extensions::ExtensionSystem::Get(profile)->event_router()->
-          ExtensionHasEventListener(extension_id,
-                                    omnibox::OnInputChanged::kEventName))
+  if (!ExtensionSystem::Get(profile)->event_router()->ExtensionHasEventListener(
+           extension_id, omnibox::OnInputChanged::kEventName))
     return false;
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Set(0, new base::StringValue(input));
   args->Set(1, new base::FundamentalValue(suggest_id));
 
   scoped_ptr<Event> event(new Event(omnibox::OnInputChanged::kEventName,
                                     args.Pass()));
   event->restrict_to_browser_context = profile;
   ExtensionSystem::Get(profile)->event_router()->
       DispatchEventToExtension(extension_id, event.Pass());
   return true;
 }
 
 // static
 void ExtensionOmniboxEventRouter::OnInputEntered(
     content::WebContents* web_contents,
     const std::string& extension_id,
     const std::string& input,
     WindowOpenDisposition disposition) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   const Extension* extension =
-      ExtensionSystem::Get(profile)->extension_service()->extensions()->
-          GetByID(extension_id);
+      ExtensionRegistry::Get(profile)->enabled_extensions().GetByID(
+          extension_id);
   CHECK(extension);
   extensions::TabHelper::FromWebContents(web_contents)->
       active_tab_permission_granter()->GrantIfRequested(extension);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Set(0, new base::StringValue(input));
   if (disposition == NEW_FOREGROUND_TAB)
     args->Set(1, new base::StringValue(kForegroundTabDisposition));
   else if (disposition == NEW_BACKGROUND_TAB)
     args->Set(1, new base::StringValue(kBackgroundTabDisposition));
@@ skipping 120 matching lines @@
     url_service_->RegisterOmniboxKeyword((*i)->id(),
                                          (*i)->name(),
                                          OmniboxInfo::GetKeyword(*i));
   }
   pending_extensions_.clear();
 }
 
 template <>
 void ProfileKeyedAPIFactory<OmniboxAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
+  DependsOn(ExtensionPrefsFactory::GetInstance());
   DependsOn(TemplateURLServiceFactory::GetInstance());
 }
 
 bool OmniboxSendSuggestionsFunction::RunImpl() {
   scoped_ptr<SendSuggestions::Params> params(
       SendSuggestions::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY,
@@ skipping 103 matching lines @@
     for (size_t i = 0; i < description_styles.size(); ++i) {
       if (description_styles[i].offset > placeholder)
         description_styles[i].offset += replacement.length() - 2;
     }
   }
 
   match->contents.assign(description);
 }
 
 }  // namespace extensions