Decouple bluetooth_event_router from extension_system.

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"
 
 #if defined(OS_CHROMEOS)
 #include <errno.h>
 #endif
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
+#include "chrome/browser/extensions/api/bluetooth/bluetooth_api_factory.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
-#include "chrome/browser/extensions/bluetooth_event_router.h"
+#include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
-#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/bluetooth.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_service_record.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_utils.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/safe_strerror_posix.h"
 #endif
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothServiceRecord;
 using device::BluetoothSocket;
 
 namespace {
 
 extensions::ExtensionBluetoothEventRouter* GetEventRouter(Profile* profile) {
-  return profile->GetExtensionService()->bluetooth_event_router();
+  return extensions::BluetoothAPI::Get(profile)->bluetooth_event_router();
 }
 
 const BluetoothAdapter* GetAdapter(Profile* profile) {
   return GetEventRouter(profile)->adapter();
 }
 
 BluetoothAdapter* GetMutableAdapter(Profile* profile) {
   BluetoothAdapter* adapter = GetEventRouter(profile)->GetMutableAdapter();
   return adapter;
 }
@@ skipping 25 matching lines @@
 namespace Connect = extensions::api::bluetooth::Connect;
 namespace Disconnect = extensions::api::bluetooth::Disconnect;
 namespace GetDevices = extensions::api::bluetooth::GetDevices;
 namespace GetServices = extensions::api::bluetooth::GetServices;
 namespace Read = extensions::api::bluetooth::Read;
 namespace SetOutOfBandPairingData =
     extensions::api::bluetooth::SetOutOfBandPairingData;
 namespace Write = extensions::api::bluetooth::Write;
 
 namespace extensions {
+
+BluetoothAPI::BluetoothAPI(Profile* profile) : profile_(profile) {
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, extensions::event_names::kBluetoothOnAvailabilityChanged);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, extensions::event_names::kBluetoothOnPowerChanged);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, extensions::event_names::kBluetoothOnDiscoveringChanged);
+}
+
+BluetoothAPI::~BluetoothAPI() {
+}
+
+void BluetoothAPI::Shutdown() {
+  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+}
+
+// static
+BluetoothAPI* BluetoothAPI::Get(Profile* profile) {
+  return BluetoothAPIFactory::GetForProfile(profile);
+}
+
+ExtensionBluetoothEventRouter* BluetoothAPI::bluetooth_event_router() {
+  if (!bluetooth_event_router_) {

[bryeung, 2012/11/12 20:44:39]

no braces

[youngki, 2012/11/13 01:14:13]

Done.

+    bluetooth_event_router_.reset(new ExtensionBluetoothEventRouter(profile_));
+  }
+  return bluetooth_event_router_.get();
+}
+
+void BluetoothAPI::OnListenerAdded(const std::string& event_name) {
+  NOTIMPLEMENTED();

[Yoyo Zhou, 2012/11/12 20:03:56]

I don't understand. Can you explain what this is for?

By the way, ProcessesAPI is slightly unusual. The intended pattern is: if you
want to start the event router once there is a bluetooth API listener, then:

- Register with EventRouter in the API constructor
- Unregister in API::Shutdown
- In OnListenerAdded, start the event router, and also unregister
- Don't need to implement OnListenerRemoved

And the possible lazy start in bluetooth_event_router() still looks necessary
because BluetoothEventRouter is also used by API function calls defined in this
file. (Ideally, those would be attached to BluetoothAPI instead. But that's a
less important cleanup.)

If, on the other hand, you need to start the event router at startup, you should
do that in the constructor and you don't need to observe EventRouter at all.

[bryeung, 2012/11/12 20:44:39]

Seems like this CL should handle the lifetime management of the DefaultAdapter
as well.

[youngki, 2012/11/13 01:14:13]

Okay I combined https://chromiumcodereview.appspot.com/11360200/ into this CL.
Hopefully the intention is clearer. Basically we'd like to let bluetooth event
router know when the events are added/removed.

+}
+
+void BluetoothAPI::OnListenerRemoved(const std::string& event_name) {
+  NOTIMPLEMENTED();
+}
+
 namespace api {
 
 bool BluetoothIsAvailableFunction::RunImpl() {
   if (!IsBluetoothSupported(profile())) {
     SetError(kPlatformNotSupported);
     return false;
   }
 
   SetResult(Value::CreateBooleanValue(GetAdapter(profile())->IsPresent()));
   return true;
@@ skipping 506 matching lines @@
   if (GetEventRouter(profile())->IsResponsibleForDiscovery()) {
     GetMutableAdapter(profile())->SetDiscovering(false,
         base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
         base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
   }
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions