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

chrome/browser/extensions/api/bluetooth/bluetooth_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/bluetooth/bluetooth_api.h"
 
 #include <string>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_socket_event_dispatcher.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/bluetooth.h"
 #include "chrome/common/extensions/api/bluetooth/bluetooth_manifest_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
 #include "device/bluetooth/bluetooth_profile.h"
 #include "device/bluetooth/bluetooth_service_record.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "extensions/browser/event_router.h"
-#include "extensions/browser/extension_system.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/base/io_buffer.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothProfile;
 using device::BluetoothServiceRecord;
@@ skipping 112 matching lines @@
   return GetFactoryInstance()->Get(context);
 }
 
 BluetoothAPI::ConnectionParams::ConnectionParams() {}
 
 BluetoothAPI::ConnectionParams::~ConnectionParams() {}
 
 BluetoothAPI::BluetoothAPI(content::BrowserContext* context)
     : browser_context_(context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
-      this, bluetooth::OnAdapterStateChanged::kEventName);
-  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
-      this, bluetooth::OnDeviceAdded::kEventName);
-  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
-      this, bluetooth::OnDeviceChanged::kEventName);
-  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
-      this, bluetooth::OnDeviceRemoved::kEventName);
+  EventRouter* event_router = EventRouter::Get(browser_context_);
+  event_router->RegisterObserver(this,
+                                 bluetooth::OnAdapterStateChanged::kEventName);
+  event_router->RegisterObserver(this, bluetooth::OnDeviceAdded::kEventName);
+  event_router->RegisterObserver(this, bluetooth::OnDeviceChanged::kEventName);
+  event_router->RegisterObserver(this, bluetooth::OnDeviceRemoved::kEventName);
 }
 
 BluetoothAPI::~BluetoothAPI() {}
 
 BluetoothEventRouter* BluetoothAPI::event_router() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!event_router_) {
     event_router_.reset(new BluetoothEventRouter(browser_context_));
   }
   return event_router_.get();
@@ skipping 19 matching lines @@
 BluetoothAPI::socket_event_dispatcher() {
   if (!socket_event_dispatcher_) {
     socket_event_dispatcher_ = new api::BluetoothSocketEventDispatcher(
         browser_context_, socket_data());
   }
   return socket_event_dispatcher_;
 }
 
 void BluetoothAPI::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ExtensionSystem::Get(browser_context_)->event_router()->UnregisterObserver(
-      this);
+  EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 void BluetoothAPI::OnListenerAdded(const EventListenerInfo& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (event_router()->IsBluetoothSupported())
     event_router()->OnListenerAdded();
 }
 
 void BluetoothAPI::OnListenerRemoved(const EventListenerInfo& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 69 matching lines @@
   api::bluetooth::Socket result_socket;
   bluetooth::BluetoothDeviceToApiDevice(*device, &result_socket.device);
   result_socket.uuid = params.uuid.canonical_value();
   result_socket.id = socket_id;
 
   scoped_ptr<base::ListValue> args =
       bluetooth::OnConnection::Create(result_socket);
   scoped_ptr<Event> event(
       new Event(bluetooth::OnConnection::kEventName, args.Pass()));
 
-  EventRouter* router = ExtensionSystem::Get(context)->event_router();
+  EventRouter* router = EventRouter::Get(context);
   if (router)
     router->DispatchEventToExtension(params.extension_id, event.Pass());
 }
 
 namespace api {
 
 BluetoothSocketApiFunction::BluetoothSocketApiFunction() {}
 
 BluetoothSocketApiFunction::~BluetoothSocketApiFunction() {}
 
@@ skipping 550 matching lines @@
       adapter,
       extension_id(),
       base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
 
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions