Remove GetExtensionService from Profile.

chrome/browser/extensions/event_router.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/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 218 matching lines @@
     SystemInfoEventRouter::GetInstance()->RemoveEventListener(event_name);
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   scoped_ptr<EventListener> listener(new EventListener(
       event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
   bool is_new = listeners_.AddListener(listener.Pass());
 
   if (is_new) {
-    ExtensionPrefs* prefs =
-        profile_->GetExtensionService()->extension_prefs();
+    ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
+        extension_service()->extension_prefs();
     std::set<std::string> events = prefs->GetRegisteredEvents(extension_id);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       prefs->SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::RemoveLazyEventListener(const std::string& event_name,
                                           const std::string& extension_id) {
   EventListener listener(event_name, extension_id, NULL,
                          scoped_ptr<DictionaryValue>());
   bool did_exist = listeners_.RemoveListener(&listener);
 
   if (did_exist) {
-    ExtensionPrefs* prefs =
-        profile_->GetExtensionService()->extension_prefs();
+    ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
+        extension_service()->extension_prefs();
     std::set<std::string> events = prefs->GetRegisteredEvents(extension_id);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     prefs->SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::AddFilteredEventListener(const std::string& event_name,
                                            content::RenderProcessHost* process,
                                            const std::string& extension_id,
                                            const base::DictionaryValue& filter,
                                            bool add_lazy_listener) {
   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
       event_name, extension_id, process,
       scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 
   if (add_lazy_listener) {
     bool added = listeners_.AddListener(scoped_ptr<EventListener>(
         new EventListener(event_name, extension_id, NULL,
         scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 
     if (added) {
-      ExtensionPrefs* prefs =
-          profile_->GetExtensionService()->extension_prefs();
+      ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
+          extension_service()->extension_prefs();
       prefs->AddFilterToEvent(event_name, extension_id, &filter);
     }
   }
 }
 
 void EventRouter::RemoveFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const std::string& extension_id,
     const base::DictionaryValue& filter,
     bool remove_lazy_listener) {
   EventListener listener(event_name, extension_id, process,
                          scoped_ptr<DictionaryValue>(filter.DeepCopy()));
 
   listeners_.RemoveListener(&listener);
 
   if (remove_lazy_listener) {
     listener.process = NULL;
     bool removed = listeners_.RemoveListener(&listener);
 
     if (removed) {
-      ExtensionPrefs* prefs =
-          profile_->GetExtensionService()->extension_prefs();
+      ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
+          extension_service()->extension_prefs();
       prefs->RemoveFilterFromEvent(event_name, extension_id, &filter);
     }
   }
 }
 
 bool EventRouter::HasEventListener(const std::string& event_name) {
   return listeners_.HasListenerForEvent(event_name);
 }
 
 bool EventRouter::ExtensionHasEventListener(const std::string& extension_id,
@@ skipping 133 matching lines @@
         }
       }
     }
   }
 }
 
 void EventRouter::DispatchLazyEvent(
     const std::string& extension_id,
     const linked_ptr<Event>& event,
     std::set<EventDispatchIdentifier>* already_dispatched) {
-  ExtensionService* service = profile_->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
   // Check both the original and the incognito profile to see if we
   // should load a lazy bg page to handle the event. The latter case
   // occurs in the case of split-mode extensions.
   const Extension* extension = service->extensions()->GetByID(extension_id);
   if (extension) {
     if (MaybeLoadLazyBackgroundPageToDispatchEvent(
           profile_, extension, event)) {
       already_dispatched->insert(std::make_pair(profile_, extension_id));
     }
 
     if (profile_->HasOffTheRecordProfile() &&
         extension->incognito_split_mode()) {
       if (MaybeLoadLazyBackgroundPageToDispatchEvent(
           profile_->GetOffTheRecordProfile(), extension, event)) {
         already_dispatched->insert(
             std::make_pair(profile_->GetOffTheRecordProfile(), extension_id));
       }
     }
   }
 }
 
 void EventRouter::DispatchEventToProcess(const std::string& extension_id,
                                          content::RenderProcessHost* process,
                                          const linked_ptr<Event>& event) {
-  ExtensionService* service = profile_->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
   const Extension* extension = service->extensions()->GetByID(extension_id);
 
   // The extension could have been removed, but we do not unregister it until
   // the extension process is unloaded.
   if (!extension)
     return;
 
   Profile* listener_profile = Profile::FromBrowserContext(
       process->GetBrowserContext());
-  ProcessMap* process_map =
-      listener_profile->GetExtensionService()->process_map();
+  ProcessMap* process_map = extensions::ExtensionSystem::Get(listener_profile)->
+      extension_service()->process_map();
   // If the event is privileged, only send to extension processes. Otherwise,
   // it's OK to send to normal renderers (e.g., for content scripts).
   if (ExtensionAPI::GetSharedInstance()->IsPrivileged(event->event_name) &&
       !process_map->Contains(extension->id(), process->GetID())) {
     return;
   }
 
   ListValue* event_args = NULL;
   if (!CanDispatchEventToProfile(listener_profile, extension,
                                  event, &event_args)) {
@@ skipping 12 matching lines @@
                                             const linked_ptr<Event>& event,
                                             ListValue** event_args) {
   if (event_args)
     *event_args = event->event_args.get();
 
   // Is this event from a different profile than the renderer (ie, an
   // incognito tab event sent to a normal process, or vice versa).
   bool cross_incognito =
       event->restrict_to_profile && profile != event->restrict_to_profile;
   if (cross_incognito &&
-      !profile->GetExtensionService()->CanCrossIncognito(extension)) {
+      !extensions::ExtensionSystem::Get(profile)->extension_service()->
+          CanCrossIncognito(extension)) {
     if (!event->cross_incognito_args.get())
       return false;
     // Send the event with different arguments to extensions that can't
     // cross incognito.
     if (event_args)
       *event_args = event->cross_incognito_args.get();
   }
 
   return true;
 }
@@ skipping 82 matching lines @@
         LazyBackgroundTaskQueue* queue =
             ExtensionSystem::Get(profile_)->lazy_background_task_queue();
         queue->AddPendingTask(profile_, extension->id(),
                               base::Bind(&DoNothing));
       }
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
-      ExtensionPrefs* prefs =
-          profile_->GetExtensionService()->extension_prefs();
+      ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
+          extension_service()->extension_prefs();
       std::set<std::string> registered_events =
           prefs->GetRegisteredEvents(extension->id());
       listeners_.LoadUnfilteredLazyListeners(extension->id(),
                                              registered_events);
       const DictionaryValue* filtered_events =
           prefs->GetFilteredEvents(extension->id());
       if (filtered_events)
         listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
 
       if (dispatch_chrome_updated_event_) {
@@ skipping 64 matching lines @@
       info(info) {}
 
 Event::~Event() {}
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions