Implement BluetoothGattNotifySession::Stop on Android, 2nd attempt

device/bluetooth/bluetooth_remote_gatt_characteristic_win.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/bluetooth_remote_gatt_characteristic_win.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
-#include "device/bluetooth/bluetooth_gatt_notify_session_win.h"
+#include "device/bluetooth/bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_win.h"
 #include "device/bluetooth/bluetooth_task_manager_win.h"
 
 namespace device {
 
 BluetoothRemoteGattCharacteristicWin::BluetoothRemoteGattCharacteristicWin(
     BluetoothRemoteGattServiceWin* parent_service,
     BTH_LE_GATT_CHARACTERISTIC* characteristic_info,
     scoped_refptr<base::SequencedTaskRunner>& ui_task_runner)
@@ skipping 115 matching lines @@
     return it->second.get();
   return nullptr;
 }
 
 void BluetoothRemoteGattCharacteristicWin::StartNotifySession(
     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   if (IsNotifying()) {
-    std::unique_ptr<BluetoothGattNotifySessionWin> notify_session(
-        new BluetoothGattNotifySessionWin(weak_ptr_factory_.GetWeakPtr()));
+    std::unique_ptr<BluetoothGattNotifySession> notify_session(
+        new BluetoothGattNotifySession(weak_ptr_factory_.GetWeakPtr()));
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, base::Passed(std::move(notify_session))));
     return;
   }
 
   if (!characteristic_info_->IsNotifiable &&
       !characteristic_info_->IsIndicatable) {
     ui_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 30 matching lines @@
           ->GetWinDescriptorInfo(),
       base::Bind(
           &BluetoothRemoteGattCharacteristicWin::GattEventRegistrationCallback,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnGattCharacteristicValueChanged,
                  weak_ptr_factory_.GetWeakPtr()));
   gatt_event_registeration_in_progress_ = true;
 }
 
+void BluetoothRemoteGattCharacteristicWin::StopNotifySession(
+    BluetoothGattNotifySession* session,
+    const base::Closure& callback) {
+  NOTIMPLEMENTED();
+}
+
 void BluetoothRemoteGattCharacteristicWin::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   if (!characteristic_info_.get()->IsReadable) {
     error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED);
     return;
   }
 
@@ skipping 45 matching lines @@
       parent_service_->GetServicePath(), characteristic_info_.get(),
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnGetIncludedDescriptorsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 uint16_t BluetoothRemoteGattCharacteristicWin::GetAttributeHandle() const {
   return characteristic_info_->AttributeHandle;
 }
 
+void BluetoothRemoteGattCharacteristicWin::SubscribeToNotifications(
+    BluetoothRemoteGattDescriptor* ccc_descriptor,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  NOTIMPLEMENTED();
+}
+
+void BluetoothRemoteGattCharacteristicWin::UnsubscribeFromNotifications(
+    BluetoothRemoteGattDescriptor* ccc_descriptor,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  NOTIMPLEMENTED();
+}
+
 void BluetoothRemoteGattCharacteristicWin::OnGetIncludedDescriptorsCallback(
     std::unique_ptr<BTH_LE_GATT_DESCRIPTOR> descriptors,
     uint16_t num,
     HRESULT hr) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   UpdateIncludedDescriptors(descriptors.get(), num);
   if (!characteristic_added_notified_) {
     characteristic_added_notified_ = true;
     parent_service_->GetWinAdapter()->NotifyGattCharacteristicAdded(this);
@@ skipping 140 matching lines @@
     HRESULT hr) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   gatt_event_registeration_in_progress_ = false;
   std::vector<std::pair<NotifySessionCallback, ErrorCallback>> callbacks;
   callbacks.swap(start_notify_session_callbacks_);
   if (SUCCEEDED(hr)) {
     gatt_event_handle_ = event_handle;
     for (const auto& callback : callbacks) {
       callback.first.Run(base::WrapUnique(
-          new BluetoothGattNotifySessionWin(weak_ptr_factory_.GetWeakPtr())));
+          new BluetoothGattNotifySession(weak_ptr_factory_.GetWeakPtr())));
     }
   } else {
     for (const auto& callback : callbacks)
       callback.second.Run(HRESULTToGattErrorCode(hr));
   }
 }
 
 void BluetoothRemoteGattCharacteristicWin::ClearIncludedDescriptors() {
   // Explicitly reset to null to ensure that calling GetDescriptor() on the
   // removed descriptor in GattDescriptorRemoved() returns null.
   for (auto& entry : included_descriptors_)
     entry.second.reset();
   included_descriptors_.clear();
 }
 
 }  // namespace device.