Move chrome.bluetoothLowEnergy out of //chrome.

extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_event_router.cc

 // Copyright 2014 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_low_energy/bluetooth_low_energy_event_router.h"
+#include "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_connection.h"
-#include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_notify_session.h"
-#include "chrome/browser/extensions/api/bluetooth_low_energy/utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 #include "device/bluetooth/bluetooth_local_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_local_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor.h"
 #include "extensions/browser/api/api_resource_manager.h"
+#include "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_connection.h"
+#include "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_notify_session.h"
+#include "extensions/browser/api/bluetooth_low_energy/utils.h"
 #include "extensions/browser/event_listener_map.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/api/bluetooth/bluetooth_manifest_data.h"
 #include "extensions/common/extension.h"
 
 using content::BrowserThread;
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
@@ skipping 119 matching lines @@
   ConnectionResourceManager* manager = ConnectionResourceManager::Get(context);
   DCHECK(manager)
       << "There is no Bluetooth low energy connection manager. "
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "ApiResourceManager<BluetoothLowEnergyConnection>.";
   return manager;
 }
 
 typedef extensions::ApiResourceManager<
-    extensions::BluetoothLowEnergyNotifySession> NotifySessionResourceManager;
+    extensions::BluetoothLowEnergyNotifySession>
+    NotifySessionResourceManager;
 NotifySessionResourceManager* GetNotifySessionResourceManager(
     content::BrowserContext* context) {
   NotifySessionResourceManager* manager =
       NotifySessionResourceManager::Get(context);
   DCHECK(manager)
       << "There is no Bluetooth low energy value update session manager."
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "ApiResourceManager<BluetoothLowEnergyNotifySession>.";
   return manager;
@@ skipping 105 matching lines @@
   if (!IsBluetoothSupported())
     return false;
 
   if (adapter_.get()) {
     callback.Run();
     return true;
   }
 
   BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothLowEnergyEventRouter::OnGetAdapter,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 weak_ptr_factory_.GetWeakPtr(), callback));
   return true;
 }
 
 bool BluetoothLowEnergyEventRouter::HasAdapter() const {
   return (adapter_.get() != NULL);
 }
 
 void BluetoothLowEnergyEventRouter::Connect(
     bool persistent,
     const Extension* extension,
@@ skipping 31 matching lines @@
   BluetoothDevice* device = adapter_->GetDevice(device_address);
   if (!device) {
     VLOG(1) << "Bluetooth device not found: " << device_address;
     error_callback.Run(kStatusErrorNotFound);
     return;
   }
 
   connecting_devices_.insert(connect_id);
   device->CreateGattConnection(
       base::Bind(&BluetoothLowEnergyEventRouter::OnCreateGattConnection,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 persistent,
-                 extension_id,
-                 device_address,
-                 callback),
+                 weak_ptr_factory_.GetWeakPtr(), persistent, extension_id,
+                 device_address, callback),
       base::Bind(&BluetoothLowEnergyEventRouter::OnConnectError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 device_address,
+                 weak_ptr_factory_.GetWeakPtr(), extension_id, device_address,
                  error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::Disconnect(
     const Extension* extension,
     const std::string& device_address,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!adapter_.get()) {
@@ skipping 269 matching lines @@
       characteristic->GetService()->GetUUID().value());
   if (!BluetoothManifestData::CheckRequest(extension, request)) {
     VLOG(1) << "App has no permission to access this characteristic: "
             << instance_id;
     error_callback.Run(kStatusErrorPermissionDenied);
     return;
   }
 
   characteristic->ReadRemoteCharacteristic(
       base::Bind(&BluetoothLowEnergyEventRouter::OnValueSuccess,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback),
+                 weak_ptr_factory_.GetWeakPtr(), callback),
       base::Bind(&BluetoothLowEnergyEventRouter::OnError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 error_callback));
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::WriteCharacteristicValue(
     const Extension* extension,
     const std::string& instance_id,
     const std::vector<uint8_t>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
@@ skipping 14 matching lines @@
   BluetoothPermissionRequest request(
       characteristic->GetService()->GetUUID().value());
   if (!BluetoothManifestData::CheckRequest(extension, request)) {
     VLOG(1) << "App has no permission to access this characteristic: "
             << instance_id;
     error_callback.Run(kStatusErrorPermissionDenied);
     return;
   }
 
   characteristic->WriteRemoteCharacteristic(
-      value,
-      callback,
+      value, callback,
       base::Bind(&BluetoothLowEnergyEventRouter::OnError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 error_callback));
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::StartCharacteristicNotifications(
     bool persistent,
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!adapter_.get()) {
@@ skipping 36 matching lines @@
   if (!BluetoothManifestData::CheckRequest(extension, request)) {
     VLOG(1) << "App has no permission to access this characteristic: "
             << instance_id;
     error_callback.Run(kStatusErrorPermissionDenied);
     return;
   }
 
   pending_session_calls_.insert(session_id);
   characteristic->StartNotifySession(
       base::Bind(&BluetoothLowEnergyEventRouter::OnStartNotifySession,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 persistent,
-                 extension_id,
-                 instance_id,
-                 callback),
+                 weak_ptr_factory_.GetWeakPtr(), persistent, extension_id,
+                 instance_id, callback),
       base::Bind(&BluetoothLowEnergyEventRouter::OnStartNotifySessionError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 instance_id,
+                 weak_ptr_factory_.GetWeakPtr(), extension_id, instance_id,
                  error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::StopCharacteristicNotifications(
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   const std::string extension_id = extension->id();
 
   BluetoothLowEnergyNotifySession* session =
       FindNotifySession(extension_id, instance_id);
   if (!session || !session->GetSession()->IsActive()) {
     VLOG(1) << "Application has not enabled notifications from "
             << "characteristic: " << instance_id;
     error_callback.Run(kStatusErrorNotNotifying);
     return;
   }
 
-  session->GetSession()->Stop(
-      base::Bind(&BluetoothLowEnergyEventRouter::OnStopNotifySession,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 instance_id,
-                 callback));
+  session->GetSession()->Stop(base::Bind(
+      &BluetoothLowEnergyEventRouter::OnStopNotifySession,
+      weak_ptr_factory_.GetWeakPtr(), extension_id, instance_id, callback));
 }
 
 void BluetoothLowEnergyEventRouter::ReadDescriptorValue(
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   if (!adapter_.get()) {
@@ skipping 13 matching lines @@
       descriptor->GetCharacteristic()->GetService()->GetUUID().value());
   if (!BluetoothManifestData::CheckRequest(extension, request)) {
     VLOG(1) << "App has no permission to access this descriptor: "
             << instance_id;
     error_callback.Run(kStatusErrorPermissionDenied);
     return;
   }
 
   descriptor->ReadRemoteDescriptor(
       base::Bind(&BluetoothLowEnergyEventRouter::OnValueSuccess,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback),
+                 weak_ptr_factory_.GetWeakPtr(), callback),
       base::Bind(&BluetoothLowEnergyEventRouter::OnError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 error_callback));
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::WriteDescriptorValue(
     const Extension* extension,
     const std::string& instance_id,
     const std::vector<uint8_t>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
@@ skipping 13 matching lines @@
   BluetoothPermissionRequest request(
       descriptor->GetCharacteristic()->GetService()->GetUUID().value());
   if (!BluetoothManifestData::CheckRequest(extension, request)) {
     VLOG(1) << "App has no permission to access this descriptor: "
             << instance_id;
     error_callback.Run(kStatusErrorPermissionDenied);
     return;
   }
 
   descriptor->WriteRemoteDescriptor(
-      value,
-      callback,
+      value, callback,
       base::Bind(&BluetoothLowEnergyEventRouter::OnError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 error_callback));
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::SetAdapterForTesting(
     device::BluetoothAdapter* adapter) {
   adapter_ = adapter;
   InitializeIdentifierMappings();
 }
 
 void BluetoothLowEnergyEventRouter::GattServiceAdded(
     BluetoothAdapter* adapter,
@@ skipping 540 matching lines @@
 }
 
 void BluetoothLowEnergyEventRouter::InitializeIdentifierMappings() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(service_id_to_device_address_.empty());
   DCHECK(chrc_id_to_service_id_.empty());
 
   // Devices
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   for (BluetoothAdapter::DeviceList::iterator iter = devices.begin();
-       iter != devices.end();
-       ++iter) {
+       iter != devices.end(); ++iter) {
     BluetoothDevice* device = *iter;
 
     // Services
     std::vector<BluetoothRemoteGattService*> services =
         device->GetGattServices();
     for (std::vector<BluetoothRemoteGattService*>::iterator siter =
              services.begin();
          siter != services.end(); ++siter) {
       BluetoothRemoteGattService* service = *siter;
 
@@ skipping 370 matching lines @@
     const std::string& extension_id,
     const std::string& device_address) {
   ConnectionResourceManager* manager =
       GetConnectionResourceManager(browser_context_);
 
   base::hash_set<int>* connection_ids = manager->GetResourceIds(extension_id);
   if (!connection_ids)
     return NULL;
 
   for (base::hash_set<int>::const_iterator iter = connection_ids->begin();
-       iter != connection_ids->end();
-       ++iter) {
+       iter != connection_ids->end(); ++iter) {
     extensions::BluetoothLowEnergyConnection* conn =
         manager->Get(extension_id, *iter);
     if (!conn)
       continue;
 
     if (conn->GetConnection()->GetDeviceAddress() == device_address)
       return conn;
   }
 
   return NULL;
 }
 
 bool BluetoothLowEnergyEventRouter::RemoveConnection(
     const std::string& extension_id,
     const std::string& device_address) {
   ConnectionResourceManager* manager =
       GetConnectionResourceManager(browser_context_);
 
   base::hash_set<int>* connection_ids = manager->GetResourceIds(extension_id);
   if (!connection_ids)
     return false;
 
   for (base::hash_set<int>::const_iterator iter = connection_ids->begin();
-       iter != connection_ids->end();
-       ++iter) {
+       iter != connection_ids->end(); ++iter) {
     extensions::BluetoothLowEnergyConnection* conn =
         manager->Get(extension_id, *iter);
     if (!conn || conn->GetConnection()->GetDeviceAddress() != device_address)
       continue;
 
     manager->Remove(extension_id, *iter);
     return true;
   }
 
   return false;
 }
 
 BluetoothLowEnergyNotifySession*
 BluetoothLowEnergyEventRouter::FindNotifySession(
     const std::string& extension_id,
     const std::string& characteristic_id) {
   NotifySessionResourceManager* manager =
       GetNotifySessionResourceManager(browser_context_);
 
   base::hash_set<int>* ids = manager->GetResourceIds(extension_id);
   if (!ids)
     return NULL;
 
   for (base::hash_set<int>::const_iterator iter = ids->begin();
-       iter != ids->end();
-       ++iter) {
+       iter != ids->end(); ++iter) {
     BluetoothLowEnergyNotifySession* session =
         manager->Get(extension_id, *iter);
     if (!session)
       continue;
 
     if (session->GetSession()->GetCharacteristicIdentifier() ==
         characteristic_id)
       return session;
   }
 
   return NULL;
 }
 
 bool BluetoothLowEnergyEventRouter::RemoveNotifySession(
     const std::string& extension_id,
     const std::string& characteristic_id) {
   NotifySessionResourceManager* manager =
       GetNotifySessionResourceManager(browser_context_);
 
   base::hash_set<int>* ids = manager->GetResourceIds(extension_id);
   if (!ids)
     return false;
 
   for (base::hash_set<int>::const_iterator iter = ids->begin();
-       iter != ids->end();
-       ++iter) {
+       iter != ids->end(); ++iter) {
     BluetoothLowEnergyNotifySession* session =
         manager->Get(extension_id, *iter);
     if (!session ||
         session->GetSession()->GetCharacteristicIdentifier() !=
             characteristic_id)
       continue;
 
     manager->Remove(extension_id, *iter);
     return true;
   }
@@ skipping 14 matching lines @@
     requests_[extension_id] = std::move(new_request_id_map);
   } else {
     request_id_map = iter->second.get();
   }
 
   (*request_id_map)[++last_callback_request_id_] = std::move(request);
   return last_callback_request_id_;
 }
 
 }  // namespace extensions