Implement chrome.bluetoothLowEnergy.resetAdvertising().

device/bluetooth/bluez/bluetooth_adapter_bluez.cc

 // Copyright 2013 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 "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <memory>
@@ skipping 132 matching lines @@
 
   device::BluetoothAdvertisement::ErrorCode code = device::
       BluetoothAdvertisement::ErrorCode::INVALID_ADVERTISEMENT_ERROR_CODE;
   if (error_name == bluetooth_advertising_manager::kErrorInvalidArguments) {
     code = device::BluetoothAdvertisement::ErrorCode::
         ERROR_INVALID_ADVERTISEMENT_INTERVAL;
   }
   error_callback.Run(code);
 }
 
+void ResetAdvertisingErrorCallbackConnector(
+    const device::BluetoothAdapter::AdvertisementErrorCallback& error_callback,
+    const std::string& error_name,
+    const std::string& error_message) {
+  BLUETOOTH_LOG(ERROR) << "Error while resetting advertising. error_name = "
+                       << error_name << ", error_message = " << error_message;
+
+  error_callback.Run(
+      device::BluetoothAdvertisement::ErrorCode::ERROR_RESET_ADVERTISING);
+}
+
 }  // namespace
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapterBlueZ::CreateAdapter(
     const InitCallback& init_callback) {
   BluetoothAdapterBlueZ* adapter = new BluetoothAdapterBlueZ(init_callback);
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 void BluetoothAdapterBlueZ::Shutdown() {
@@ skipping 352 matching lines @@
   uint16_t max_ms = static_cast<uint16_t>(
       std::min(static_cast<int64_t>(std::numeric_limits<uint16_t>::max()),
                max.InMilliseconds()));
   bluez::BluezDBusManager::Get()
       ->GetBluetoothLEAdvertisingManagerClient()
       ->SetAdvertisingInterval(
           object_path_, min_ms, max_ms, callback,
           base::Bind(&SetIntervalErrorCallbackConnector, error_callback));
 }
 
+void BluetoothAdapterBlueZ::ResetAdvertising(
+    const base::Closure& callback,
+    const AdvertisementErrorCallback& error_callback) {
+  DCHECK(bluez::BluezDBusManager::Get());
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothLEAdvertisingManagerClient()
+      ->ResetAdvertising(
+          object_path_, callback,
+          base::Bind(&ResetAdvertisingErrorCallbackConnector, error_callback));
+}
+
 device::BluetoothLocalGattService* BluetoothAdapterBlueZ::GetGattService(
     const std::string& identifier) const {
   const auto& service = owned_gatt_services_.find(dbus::ObjectPath(identifier));
   return service == owned_gatt_services_.end() ? nullptr
                                                : service->second.get();
 }
 
 void BluetoothAdapterBlueZ::RemovePairingDelegateInternal(
     BluetoothDevice::PairingDelegate* pairing_delegate) {
   // Check if any device is using the pairing delegate.
@@ skipping 1213 matching lines @@
   } else if (error_name == bluetooth_adapter::kErrorAlreadyExists) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_RECORD_ALREADY_EXISTS;
   } else if (error_name == bluetooth_adapter::kErrorNotReady) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_ADAPTER_NOT_READY;
   }
 
   error_callback.Run(code);
 }
 
 }  // namespace bluez