Implement BluetoothGattNotifySession::Stop on Android, 2nd attempt

device/bluetooth/bluez/bluetooth_remote_gatt_characteristic_bluez.cc

 // Copyright 2016 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_remote_gatt_characteristic_bluez.h"
 
 #include <iterator>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "dbus/property.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 #include "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
-#include "device/bluetooth/bluez/bluetooth_gatt_notify_session_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_remote_gatt_descriptor_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_remote_gatt_service_bluez.h"
 #include "device/bluetooth/dbus/bluetooth_gatt_characteristic_client.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
 namespace {
 
@@ skipping 46 matching lines @@
     delete iter->second;
 
   // Report an error for all pending calls to StartNotifySession.
   while (!pending_start_notify_calls_.empty()) {
     PendingStartNotifyCall callbacks = pending_start_notify_calls_.front();
     pending_start_notify_calls_.pop();
     callbacks.second.Run(device::BluetoothRemoteGattService::GATT_ERROR_FAILED);
   }
 }
 
+void BluetoothRemoteGattCharacteristicBlueZ::StopNotifySession(
+    device::BluetoothGattNotifySession* session,
+    const base::Closure& callback) {
+  VLOG(1) << __func__;
+
+  if (num_notify_sessions_ > 1) {
+    DCHECK(!notify_call_pending_);
+    --num_notify_sessions_;
+    callback.Run();
+    return;
+  }
+
+  // Notifications may have stopped outside our control. If the characteristic
+  // is no longer notifying, return success.
+  if (!IsNotifying()) {
+    num_notify_sessions_ = 0;
+    callback.Run();
+    return;
+  }
+
+  if (notify_call_pending_ || num_notify_sessions_ == 0) {
+    callback.Run();
+    return;
+  }
+
+  DCHECK(num_notify_sessions_ == 1);
+  notify_call_pending_ = true;
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothGattCharacteristicClient()
+      ->StopNotify(
+          object_path(),
+          base::Bind(
+              &BluetoothRemoteGattCharacteristicBlueZ::OnStopNotifySuccess,
+              weak_ptr_factory_.GetWeakPtr(), callback),
+          base::Bind(&BluetoothRemoteGattCharacteristicBlueZ::OnStopNotifyError,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
 device::BluetoothUUID BluetoothRemoteGattCharacteristicBlueZ::GetUUID() const {
   bluez::BluetoothGattCharacteristicClient::Properties* properties =
       bluez::BluezDBusManager::Get()
           ->GetBluetoothGattCharacteristicClient()
           ->GetProperties(object_path());
   DCHECK(properties);
   return device::BluetoothUUID(properties->uuid.value());
 }
 
 device::BluetoothRemoteGattCharacteristic::Properties
@@ skipping 103 matching lines @@
         error_callback.Run(
             device::BluetoothRemoteGattService::GATT_ERROR_FAILED);
         return;
       }
 
       ++num_notify_sessions_;
       DCHECK(service_);
       DCHECK(service_->GetAdapter());
       DCHECK(service_->GetDevice());
       std::unique_ptr<device::BluetoothGattNotifySession> session(
-          new BluetoothGattNotifySessionBlueZ(
-              service_->GetAdapter(), service_->GetDevice()->GetAddress(),
-              service_->GetIdentifier(), GetIdentifier(), object_path()));
+          new device::BluetoothGattNotifySession(
+              weak_ptr_factory_.GetWeakPtr()));
       callback.Run(std::move(session));
       return;
     }
 
     num_notify_sessions_ = 0;
   }
 
   // Queue the callbacks if there is a pending call to bluetoothd.
   if (notify_call_pending_) {
     pending_start_notify_calls_.push(std::make_pair(callback, error_callback));
@@ skipping 35 matching lines @@
           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value()
           << ", with value: " << new_value << ".";
 
   bluez::BluezDBusManager::Get()
       ->GetBluetoothGattCharacteristicClient()
       ->WriteValue(object_path(), new_value, callback,
                    base::Bind(&BluetoothRemoteGattCharacteristicBlueZ::OnError,
                               weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
-void BluetoothRemoteGattCharacteristicBlueZ::RemoveNotifySession(
-    const base::Closure& callback) {
-  VLOG(1) << __func__;
+void BluetoothRemoteGattCharacteristicBlueZ::SubscribeToNotifications(
+    device::BluetoothRemoteGattDescriptor* ccc_descriptor,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  // TODO(http://crbug.com/636275): Implement this method
+  NOTIMPLEMENTED();
+}
 
-  if (num_notify_sessions_ > 1) {
-    DCHECK(!notify_call_pending_);
-    --num_notify_sessions_;
-    callback.Run();
-    return;
-  }
-
-  // Notifications may have stopped outside our control. If the characteristic
-  // is no longer notifying, return success.
-  if (!IsNotifying()) {
-    num_notify_sessions_ = 0;
-    callback.Run();
-    return;
-  }
-
-  if (notify_call_pending_ || num_notify_sessions_ == 0) {
-    callback.Run();
-    return;
-  }
-
-  DCHECK(num_notify_sessions_ == 1);
-  notify_call_pending_ = true;
-  bluez::BluezDBusManager::Get()
-      ->GetBluetoothGattCharacteristicClient()
-      ->StopNotify(
-          object_path(),
-          base::Bind(
-              &BluetoothRemoteGattCharacteristicBlueZ::OnStopNotifySuccess,
-              weak_ptr_factory_.GetWeakPtr(), callback),
-          base::Bind(&BluetoothRemoteGattCharacteristicBlueZ::OnStopNotifyError,
-                     weak_ptr_factory_.GetWeakPtr(), callback));
+void BluetoothRemoteGattCharacteristicBlueZ::UnsubscribeFromNotifications(
+    device::BluetoothRemoteGattDescriptor* ccc_descriptor,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  // TODO(http://crbug.com/636275): Implement this method
+  NOTIMPLEMENTED();
 }
 
 void BluetoothRemoteGattCharacteristicBlueZ::GattDescriptorAdded(
     const dbus::ObjectPath& object_path) {
   if (descriptors_.find(object_path) != descriptors_.end()) {
     VLOG(1) << "Remote GATT characteristic descriptor already exists: "
             << object_path.value();
     return;
   }
 
@@ skipping 75 matching lines @@
   DCHECK(num_notify_sessions_ == 0);
   DCHECK(notify_call_pending_);
 
   ++num_notify_sessions_;
   notify_call_pending_ = false;
 
   // Invoke the queued callbacks for this operation.
   DCHECK(service_);
   DCHECK(service_->GetDevice());
   std::unique_ptr<device::BluetoothGattNotifySession> session(
-      new BluetoothGattNotifySessionBlueZ(
-          service_->GetAdapter(), service_->GetDevice()->GetAddress(),
-          service_->GetIdentifier(), GetIdentifier(), object_path()));
+      new device::BluetoothGattNotifySession(weak_ptr_factory_.GetWeakPtr()));
   callback.Run(std::move(session));
 
   ProcessStartNotifyQueue();
 }
 
 void BluetoothRemoteGattCharacteristicBlueZ::OnStartNotifyError(
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   VLOG(1) << "Failed to start notifications from characteristic: "
@@ skipping 46 matching lines @@
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   VLOG(1) << "Operation failed: " << error_name
           << ", message: " << error_message;
   error_callback.Run(
       BluetoothGattServiceBlueZ::DBusErrorToServiceError(error_name));
 }
 
 }  // namespace bluez