cleanup: Use EventRouter instead of ExtensionSystem::Get->event_router()

chrome/browser/extensions/api/cookies/cookies_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.
 
 // Implements the Chrome Extensions Cookies API.
 
 #include "chrome/browser/extensions/api/cookies/cookies_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/cookies/cookies_api_constants.h"
 #include "chrome/browser/extensions/api/cookies/cookies_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/common/extensions/api/cookies.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/event_router.h"
-#include "extensions/browser/extension_system.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
@@ skipping 88 matching lines @@
   DispatchEvent(profile,
                 cookies::OnChanged::kEventName,
                 args.Pass(),
                 cookie_domain);
 }
 
 void CookiesEventRouter::DispatchEvent(content::BrowserContext* context,
                                        const std::string& event_name,
                                        scoped_ptr<base::ListValue> event_args,
                                        GURL& cookie_domain) {
-  EventRouter* router =
-      context ? extensions::ExtensionSystem::Get(context)->event_router()
-              : NULL;
+  EventRouter* router = context ? extensions::EventRouter::Get(context) : NULL;
   if (!router)
     return;
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
   event->restrict_to_browser_context = context;
   event->event_url = cookie_domain;
   router->BroadcastEvent(event.Pass());
 }
 
 bool CookiesFunction::ParseUrl(const std::string& url_string, GURL* url,
                                bool check_host_permissions) {
@@ skipping 405 matching lines @@
   results_ = GetAllCookieStores::Results::Create(cookie_stores);
   return true;
 }
 
 void CookiesGetAllCookieStoresFunction::Run() {
   SendResponse(RunImpl());
 }
 
 CookiesAPI::CookiesAPI(content::BrowserContext* context)
     : browser_context_(context) {
-  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
-      this, cookies::OnChanged::kEventName);
+  EventRouter::Get(browser_context_)
+      ->RegisterObserver(this, cookies::OnChanged::kEventName);
 }
 
 CookiesAPI::~CookiesAPI() {
 }
 
 void CookiesAPI::Shutdown() {
-  ExtensionSystem::Get(browser_context_)->event_router()->UnregisterObserver(
-      this);
+  EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<CookiesAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CookiesAPI>* CookiesAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void CookiesAPI::OnListenerAdded(
     const extensions::EventListenerInfo& details) {
   cookies_event_router_.reset(new CookiesEventRouter(browser_context_));
-  ExtensionSystem::Get(browser_context_)->event_router()->UnregisterObserver(
-      this);
+  EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions