bluetooth: Require frame to be connected for startNotifications to succeed.

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // Copyright 2015 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 "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 653 matching lines @@
   std::unique_ptr<NiceMockBluetoothGattService> health_thermometer(
       GetBaseGATTService("Health Thermometer", device.get(),
                          kHealthThermometerUUID));
 
   // Measurement Interval
   std::unique_ptr<NiceMockBluetoothGattCharacteristic> measurement_interval(
       GetBaseGATTCharacteristic(
           "Measurement Interval", health_thermometer.get(),
           kMeasurementIntervalUUID,
           BluetoothRemoteGattCharacteristic::PROPERTY_READ |
-          BluetoothRemoteGattCharacteristic::PROPERTY_WRITE));
+              BluetoothRemoteGattCharacteristic::PROPERTY_WRITE |
+              BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       measurement_interval.get();
 
   ON_CALL(*measurement_interval, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter_ptr, measurement_ptr]() {
             std::vector<uint8_t> interval({1});
             for (auto& observer : adapter_ptr->GetObservers()) {
               observer.GattCharacteristicValueChanged(
                   adapter_ptr, measurement_ptr, interval);
             }
             return interval;
           }));
 
   ON_CALL(*measurement_interval, WriteRemoteCharacteristic(_, _, _))
-      .WillByDefault(RunCallback<1 /* success callback */>());
+      .WillByDefault(RunCallback<1 /* success_callback */>());
 
-  // TODO(crbug.com/608538): Mock StartNotifySession.
+  ON_CALL(*measurement_interval, StartNotifySession(_, _))
+      .WillByDefault(
+          RunCallbackWithResult<0 /* success_callback */>([measurement_ptr]() {
+            return GetBaseGATTNotifySession(measurement_ptr->GetWeakPtr());
+          }));
 
   health_thermometer->AddMockCharacteristic(std::move(measurement_interval));
   device->AddMockService(std::move(health_thermometer));
 
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
@@ skipping 198 matching lines @@
   std::unique_ptr<NiceMockBluetoothGattService> health_thermometer(
       GetBaseGATTService("Health Thermometer", device.get(),
                          kHealthThermometerUUID));
 
   // Measurement Interval
   std::unique_ptr<NiceMockBluetoothGattCharacteristic> measurement_interval(
       GetBaseGATTCharacteristic(
           "Measurement Interval", health_thermometer.get(),
           kMeasurementIntervalUUID,
           BluetoothRemoteGattCharacteristic::PROPERTY_READ |
-          BluetoothRemoteGattCharacteristic::PROPERTY_WRITE));
+              BluetoothRemoteGattCharacteristic::PROPERTY_WRITE |
+              BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       measurement_interval.get();
 
   ON_CALL(*measurement_interval, ReadRemoteCharacteristic(_, _))
       .WillByDefault(Invoke([adapter_ptr, device_ptr, measurement_ptr,
                              disconnect, succeeds](
           const BluetoothRemoteGattCharacteristic::ValueCallback& callback,
           const BluetoothRemoteGattCharacteristic::ErrorCallback&
               error_callback) {
         base::Closure pending;
@@ skipping 29 matching lines @@
         }
         device_ptr->PushPendingCallback(pending);
         if (disconnect) {
           device_ptr->SetConnected(false);
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&NotifyDeviceChanged, base::RetainedRef(adapter_ptr),
                          device_ptr));
         }
       }));
+
+  ON_CALL(*measurement_interval, StartNotifySession(_, _))
+      .WillByDefault(Invoke([adapter_ptr, device_ptr, measurement_ptr,
+                             disconnect, succeeds](
+          const BluetoothRemoteGattCharacteristic::NotifySessionCallback&
+              callback,
+          const BluetoothRemoteGattCharacteristic::ErrorCallback&
+              error_callback) {
+        base::Closure pending;
+        if (succeeds) {
+          pending = base::Bind(callback, base::Passed(GetBaseGATTNotifySession(
+                                             measurement_ptr->GetWeakPtr())));
+        } else {
+          pending = base::Bind(error_callback,
+                               BluetoothRemoteGattService::GATT_ERROR_FAILED);
+        }
+        device_ptr->PushPendingCallback(pending);
+        if (disconnect) {
+          device_ptr->SetConnected(false);
+          base::ThreadTaskRunnerHandle::Get()->PostTask(
+              FROM_HERE,
+              base::Bind(&NotifyDeviceChanged, base::RetainedRef(adapter_ptr),
+                         device_ptr));
+        }
+      }));
+
   health_thermometer->AddMockCharacteristic(std::move(measurement_interval));
   device->AddMockService(std::move(health_thermometer));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBlacklistTestAdapter() {
@@ skipping 588 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content