bluetooth: implement new WriteRemoteCharacteristic

After deprecating the previous implementation, we need to create a new
implementation that allows selecting write with or without response.

The new implementation is simply a copy of the deprecated implementation
with the following changes:

- An enum WriteType parameter is added to select with or without
  response.
- All GATT characteristic property checks are removed and the new enum
  parameter is used to select the write type instead.
- Additional write flags parameters are added to the platform-specific
  backends as needed.
  - For most platforms, these are just bit flags/enums.
  - For BlueZ, this is a string.
  - On the "win" backend, the part that depends on the characteristic
    property was moved to the DeprecatedWriteRemoteCharacteristic
    method since it would otherwise interfere with the new
    implementation.
  - On the "cast" backend, we are able to use the existing WriteAuth
    method without additional modification.

Likewise, the new unit tests are just a copy of the same unit tests that
call the DeprecatedWriteRemoteCharacteristic method. The new tests have
been modified to try to avoid using base::RunLoop::RunUntilIdle.

Bug: 672648
Change-Id: I7958d9e6d3fd285695091fe3220b3d2fce45c641
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2191232
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Vincent Scheib <scheib@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#769949}

device/bluetooth/android/java/src/org/chromium/device/bluetooth/ChromeBluetoothRemoteGattCharacteristic.java

@@ -130,11 +130,14 @@ final class ChromeBluetoothRemoteGattCharacteristic {
 
     // Implements BluetoothRemoteGattCharacteristicAndroid::WriteRemoteCharacteristic.
     @CalledByNative
-    private boolean writeRemoteCharacteristic(byte[] value) {
+    private boolean writeRemoteCharacteristic(byte[] value, int writeType) {
         if (!mCharacteristic.setValue(value)) {
             Log.i(TAG, "writeRemoteCharacteristic setValue failed.");
             return false;
         }
+        if (writeType != 0) {
+            mCharacteristic.setWriteType(writeType);
+        }
         if (!mChromeDevice.mBluetoothGatt.writeCharacteristic(mCharacteristic)) {
             Log.i(TAG, "writeRemoteCharacteristic writeCharacteristic failed.");
             return false;

device/bluetooth/android/java/src/org/chromium/device/bluetooth/Wrappers.java

@@ -605,6 +605,10 @@ class Wrappers {
         public boolean setValue(byte[] value) {
             return mCharacteristic.setValue(value);
         }
+
+        public void setWriteType(int writeType) {
+            mCharacteristic.setWriteType(writeType);
+        }
     }
 
     /**

device/bluetooth/bluetooth_low_energy_win.cc

@@ -801,20 +801,15 @@ HRESULT BluetoothLowEnergyWrapper::ReadCharacteristicValue(
 HRESULT BluetoothLowEnergyWrapper::WriteCharacteristicValue(
     base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
-    PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value) {
+    PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value,
+    ULONG flags) {
   base::File file(service_path, base::File::FLAG_OPEN | base::File::FLAG_READ |
                                     base::File::FLAG_WRITE);
   if (!file.IsValid())
     return HRESULT_FROM_WIN32(ERROR_OPEN_FAILED);
 
-  ULONG flag = BLUETOOTH_GATT_FLAG_NONE;
-  if (!characteristic->IsWritable) {
-    DCHECK(characteristic->IsWritableWithoutResponse);
-    flag |= BLUETOOTH_GATT_FLAG_WRITE_WITHOUT_RESPONSE;
-  }
-
   return BluetoothGATTSetCharacteristicValue(
-      file.GetPlatformFile(), characteristic, new_value, NULL, flag);
+      file.GetPlatformFile(), characteristic, new_value, {}, flags);
 }
 
 HRESULT BluetoothLowEnergyWrapper::RegisterGattEvents(

device/bluetooth/bluetooth_low_energy_win.h

@@ -188,7 +188,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothLowEnergyWrapper {
   virtual HRESULT WriteCharacteristicValue(
       base::FilePath& service_path,
       const PBTH_LE_GATT_CHARACTERISTIC characteristic,
-      PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value);
+      PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value,
+      ULONG flags);
 
   // Register GATT events of |event_type| in the service with service device
   // path |service_path|. |event_parameter| is the event's parameter. |callback|

device/bluetooth/bluetooth_low_energy_win_fake.cc

@@ -216,7 +216,15 @@ HRESULT BluetoothLowEnergyWrapperFake::ReadCharacteristicValue(
 HRESULT BluetoothLowEnergyWrapperFake::WriteCharacteristicValue(
     base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
-    PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value) {
+    PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value,
+    ULONG flags) {
+  // Web Bluetooth implementation currently only supports no flags or write
+  // without response flag even if Windows supports other flags
+  if (flags != BLUETOOTH_GATT_FLAG_NONE &&
+      flags != BLUETOOTH_GATT_FLAG_WRITE_WITHOUT_RESPONSE) {
+    return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
+  }
+
   GattCharacteristic* target_characteristic =
       GetSimulatedGattCharacteristic(service_path, characteristic);
   if (target_characteristic == nullptr)

device/bluetooth/bluetooth_low_energy_win_fake.h

@@ -130,7 +130,8 @@ class BluetoothLowEnergyWrapperFake : public BluetoothLowEnergyWrapper {
   HRESULT WriteCharacteristicValue(
       base::FilePath& service_path,
       const PBTH_LE_GATT_CHARACTERISTIC characteristic,
-      PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value) override;
+      PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value,
+      ULONG flags) override;
   HRESULT RegisterGattEvents(
       base::FilePath& service_path,
       BTH_LE_GATT_EVENT_TYPE type,

device/bluetooth/bluetooth_remote_gatt_characteristic.h

@@ -42,6 +42,12 @@ class BluetoothRemoteGattDescriptor;
 class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristic
     : public virtual BluetoothGattCharacteristic {
  public:
+  // Parameter for WriteRemoteCharacteristic
+  enum class WriteType {
+    kWithResponse,
+    kWithoutResponse,
+  };
+
   // The ValueCallback is used to return the value of a remote characteristic
   // upon a read request.
   using ValueCallback = base::OnceCallback<void(const std::vector<uint8_t>&)>;
@@ -136,6 +142,15 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristic
   virtual void ReadRemoteCharacteristic(ValueCallback callback,
                                         ErrorCallback error_callback) = 0;
 
+  // Sends a write request to a remote characteristic with the value |value|
+  // using the specified |write_type|. |callback| is called to signal success
+  // and |error_callback| for failures. This method only applies to remote
+  // characteristics and will fail for those that are locally hosted.
+  virtual void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                         WriteType write_type,
+                                         base::OnceClosure callback,
+                                         ErrorCallback error_callback) = 0;
+
   // DEPRECATED: Use WriteRemoteCharacteristic instead. This method remains
   // for backward compatibility.
   // Sends a write request to a remote characteristic with the value |value|.

device/bluetooth/bluetooth_remote_gatt_characteristic_android.cc

@@ -150,6 +150,45 @@ void BluetoothRemoteGattCharacteristicAndroid::ReadRemoteCharacteristic(
   read_error_callback_ = std::move(error_callback);
 }
 
+void BluetoothRemoteGattCharacteristicAndroid::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
+  if (read_pending_ || write_pending_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(std::move(error_callback),
+                       BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS));
+    return;
+  }
+
+  AndroidWriteType android_write_type;
+  switch (write_type) {
+    case WriteType::kWithResponse:
+      android_write_type = AndroidWriteType::kDefault;
+      break;
+    case WriteType::kWithoutResponse:
+      android_write_type = AndroidWriteType::kNoResponse;
+      break;
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+  if (!Java_ChromeBluetoothRemoteGattCharacteristic_writeRemoteCharacteristic(
+          env, j_characteristic_, base::android::ToJavaByteArray(env, value),
+          static_cast<int>(android_write_type))) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(std::move(error_callback),
+                       BluetoothRemoteGattService::GATT_ERROR_FAILED));
+    return;
+  }
+
+  write_pending_ = true;
+  write_callback_ = std::move(callback);
+  write_error_callback_ = std::move(error_callback);
+}
+
 void BluetoothRemoteGattCharacteristicAndroid::
     DeprecatedWriteRemoteCharacteristic(const std::vector<uint8_t>& value,
                                         base::OnceClosure callback,
@@ -164,7 +203,8 @@ void BluetoothRemoteGattCharacteristicAndroid::
 
   JNIEnv* env = AttachCurrentThread();
   if (!Java_ChromeBluetoothRemoteGattCharacteristic_writeRemoteCharacteristic(
-          env, j_characteristic_, base::android::ToJavaByteArray(env, value))) {
+          env, j_characteristic_, base::android::ToJavaByteArray(env, value),
+          static_cast<int>(AndroidWriteType::kNone))) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(std::move(error_callback),

device/bluetooth/bluetooth_remote_gatt_characteristic_android.h

@@ -65,6 +65,10 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristicAndroid
       const BluetoothUUID& uuid) const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,
@@ -109,6 +113,15 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristicAndroid
       ErrorCallback error_callback) override;
 
  private:
+  // Android API characteristic write type flags.
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic.html
+  enum class AndroidWriteType {
+    kNone = 0,
+    kNoResponse = 1 << 0,
+    kDefault = 1 << 1,
+    kSigned = 1 << 2,
+  };
+
   BluetoothRemoteGattCharacteristicAndroid(
       BluetoothAdapterAndroid* adapter,
       BluetoothRemoteGattServiceAndroid* service,

device/bluetooth/bluetooth_remote_gatt_characteristic_mac.h

@@ -43,6 +43,10 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristicMac
   bool IsNotifying() const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,

device/bluetooth/bluetooth_remote_gatt_characteristic_mac.mm

@@ -152,6 +152,46 @@ void BluetoothRemoteGattCharacteristicMac::ReadRemoteCharacteristic(
   [GetCBPeripheral() readValueForCharacteristic:cb_characteristic_];
 }
 
+void BluetoothRemoteGattCharacteristicMac::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
+  if (HasPendingRead() || HasPendingWrite()) {
+    DVLOG(1) << *this << ": Characteristic write already in progress.";
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(std::move(error_callback),
+                       BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS));
+    return;
+  }
+  DVLOG(1) << *this << ": Write characteristic.";
+  write_characteristic_value_callbacks_ =
+      std::make_pair(std::move(callback), std::move(error_callback));
+  base::scoped_nsobject<NSData> nsdata_value(
+      [[NSData alloc] initWithBytes:value.data() length:value.size()]);
+
+  CBCharacteristicWriteType cb_write_type;
+  switch (write_type) {
+    case WriteType::kWithResponse:
+      cb_write_type = CBCharacteristicWriteWithResponse;
+      break;
+    case WriteType::kWithoutResponse:
+      cb_write_type = CBCharacteristicWriteWithoutResponse;
+      break;
+  }
+
+  [GetCBPeripheral() writeValue:nsdata_value
+              forCharacteristic:cb_characteristic_
+                           type:cb_write_type];
+  if (cb_write_type == CBCharacteristicWriteWithoutResponse) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(&BluetoothRemoteGattCharacteristicMac::DidWriteValue,
+                       weak_ptr_factory_.GetWeakPtr(), nil));
+  }
+}
+
 void BluetoothRemoteGattCharacteristicMac::DeprecatedWriteRemoteCharacteristic(
     const std::vector<uint8_t>& value,
     base::OnceClosure callback,

device/bluetooth/bluetooth_remote_gatt_characteristic_win.cc

@@ -157,6 +157,40 @@ void BluetoothRemoteGattCharacteristicWin::ReadRemoteCharacteristic(
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void BluetoothRemoteGattCharacteristicWin::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
+
+  if (characteristic_value_read_or_write_in_progress_) {
+    std::move(error_callback)
+        .Run(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS);
+    return;
+  }
+
+  ULONG flags;
+  switch (write_type) {
+    case WriteType::kWithResponse:
+      flags = BLUETOOTH_GATT_FLAG_NONE;
+      break;
+    case WriteType::kWithoutResponse:
+      flags = BLUETOOTH_GATT_FLAG_WRITE_WITHOUT_RESPONSE;
+      break;
+  }
+
+  characteristic_value_read_or_write_in_progress_ = true;
+  write_characteristic_value_callbacks_ =
+      std::make_pair(std::move(callback), std::move(error_callback));
+  task_manager_->PostWriteGattCharacteristicValue(
+      parent_service_->GetServicePath(), characteristic_info_.get(), value,
+      flags,
+      base::Bind(&BluetoothRemoteGattCharacteristicWin::
+                     OnWriteRemoteCharacteristicValueCallback,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 void BluetoothRemoteGattCharacteristicWin::DeprecatedWriteRemoteCharacteristic(
     const std::vector<uint8_t>& value,
     base::OnceClosure callback,
@@ -176,11 +210,17 @@ void BluetoothRemoteGattCharacteristicWin::DeprecatedWriteRemoteCharacteristic(
     return;
   }
 
+  ULONG flags = BLUETOOTH_GATT_FLAG_NONE;
+  if (!characteristic_info_->IsWritable) {
+    flags |= BLUETOOTH_GATT_FLAG_WRITE_WITHOUT_RESPONSE;
+  }
+
   characteristic_value_read_or_write_in_progress_ = true;
   write_characteristic_value_callbacks_ =
       std::make_pair(std::move(callback), std::move(error_callback));
   task_manager_->PostWriteGattCharacteristicValue(
       parent_service_->GetServicePath(), characteristic_info_.get(), value,
+      flags,
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnWriteRemoteCharacteristicValueCallback,
                  weak_ptr_factory_.GetWeakPtr()));

device/bluetooth/bluetooth_remote_gatt_characteristic_win.h

@@ -44,6 +44,10 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristicWin
   bool IsNotifying() const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,

device/bluetooth/bluetooth_remote_gatt_characteristic_winrt.cc

@@ -45,6 +45,8 @@ using ABI::Windows::Devices::Bluetooth::GenericAttributeProfile::
 using ABI::Windows::Devices::Bluetooth::GenericAttributeProfile::
     GattCommunicationStatus_Success;
 using ABI::Windows::Devices::Bluetooth::GenericAttributeProfile::GattReadResult;
+using ABI::Windows::Devices::Bluetooth::GenericAttributeProfile::
+    GattWriteOption;
 using ABI::Windows::Devices::Bluetooth::GenericAttributeProfile::
     GattWriteOption_WriteWithoutResponse;
 using ABI::Windows::Devices::Bluetooth::GenericAttributeProfile::
@@ -201,19 +203,11 @@ void BluetoothRemoteGattCharacteristicWinrt::ReadRemoteCharacteristic(
       std::move(callback), std::move(error_callback));
 }
 
-void BluetoothRemoteGattCharacteristicWinrt::
-    DeprecatedWriteRemoteCharacteristic(const std::vector<uint8_t>& value,
-                                        base::OnceClosure callback,
-                                        ErrorCallback error_callback) {
-  if (!(GetProperties() & PROPERTY_WRITE) &&
-      !(GetProperties() & PROPERTY_WRITE_WITHOUT_RESPONSE)) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::BindOnce(std::move(error_callback),
-                       BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED));
-    return;
-  }
-
+void BluetoothRemoteGattCharacteristicWinrt::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
   if (pending_read_callbacks_ || pending_write_callbacks_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
@@ -246,13 +240,19 @@ void BluetoothRemoteGattCharacteristicWinrt::
     return;
   }
 
+  GattWriteOption write_option;
+  switch (write_type) {
+    case WriteType::kWithResponse:
+      write_option = GattWriteOption_WriteWithResponse;
+      break;
+    case WriteType::kWithoutResponse:
+      write_option = GattWriteOption_WriteWithoutResponse;
+      break;
+  }
+
   ComPtr<IAsyncOperation<GattWriteResult*>> write_value_op;
   hr = characteristic_3->WriteValueWithResultAndOptionAsync(
-      buffer.Get(),
-      (GetProperties() & PROPERTY_WRITE) ? GattWriteOption_WriteWithResponse
-                                         : GattWriteOption_WriteWithoutResponse,
-
-      &write_value_op);
+      buffer.Get(), write_option, &write_value_op);
   if (FAILED(hr)) {
     BLUETOOTH_LOG(DEBUG)
         << "GattCharacteristic::WriteValueWithResultAndOptionAsync failed: "
@@ -284,6 +284,27 @@ void BluetoothRemoteGattCharacteristicWinrt::
       std::move(callback), std::move(error_callback));
 }
 
+void BluetoothRemoteGattCharacteristicWinrt::
+    DeprecatedWriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                        base::OnceClosure callback,
+                                        ErrorCallback error_callback) {
+  if (!(GetProperties() & PROPERTY_WRITE) &&
+      !(GetProperties() & PROPERTY_WRITE_WITHOUT_RESPONSE)) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(std::move(error_callback),
+                       BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED));
+    return;
+  }
+
+  WriteType write_type = (GetProperties() & PROPERTY_WRITE)
+                             ? WriteType::kWithResponse
+                             : WriteType::kWithoutResponse;
+
+  WriteRemoteCharacteristic(value, write_type, std::move(callback),
+                            std::move(error_callback));
+}
+
 void BluetoothRemoteGattCharacteristicWinrt::UpdateDescriptors(
     BluetoothGattDiscovererWinrt* gatt_discoverer) {
   const auto* gatt_descriptors =

device/bluetooth/bluetooth_remote_gatt_characteristic_winrt.h

@@ -47,6 +47,10 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristicWinrt
   BluetoothRemoteGattService* GetService() const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,

device/bluetooth/bluetooth_task_manager_win.cc

@@ -869,6 +869,7 @@ void BluetoothTaskManagerWin::WriteGattCharacteristicValue(
     base::FilePath service_path,
     BTH_LE_GATT_CHARACTERISTIC characteristic,
     std::vector<uint8_t> new_value,
+    ULONG flags,
     const HResultCallback& callback) {
   ULONG length = (ULONG)(sizeof(ULONG) + new_value.size());
   std::vector<UCHAR> data(length);
@@ -880,7 +881,7 @@ void BluetoothTaskManagerWin::WriteGattCharacteristicValue(
 
   HRESULT hr = le_wrapper_->WriteCharacteristicValue(
       service_path, (PBTH_LE_GATT_CHARACTERISTIC)(&characteristic),
-      win_new_value);
+      win_new_value, flags);
 
   ui_task_runner_->PostTask(FROM_HERE, base::BindOnce(callback, hr));
 }
@@ -987,12 +988,14 @@ void BluetoothTaskManagerWin::PostWriteGattCharacteristicValue(
     const base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     const std::vector<uint8_t>& new_value,
+    ULONG flags,
     const HResultCallback& callback) {
   DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&BluetoothTaskManagerWin::WriteGattCharacteristicValue,
-                     this, service_path, *characteristic, new_value, callback));
+                     this, service_path, *characteristic, new_value, flags,
+                     callback));
 }
 
 void BluetoothTaskManagerWin::PostRegisterGattCharacteristicValueChangedEvent(

device/bluetooth/bluetooth_task_manager_win.h

@@ -186,6 +186,7 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothTaskManagerWin
       const base::FilePath& service_path,
       const PBTH_LE_GATT_CHARACTERISTIC characteristic,
       const std::vector<uint8_t>& new_value,
+      ULONG flags,
       const HResultCallback& callback);
 
   // Post a task to register to receive value changed notifications from
@@ -319,6 +320,7 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothTaskManagerWin
   void WriteGattCharacteristicValue(base::FilePath service_path,
                                     BTH_LE_GATT_CHARACTERISTIC characteristic,
                                     std::vector<uint8_t> new_value,
+                                    ULONG flags,
                                     const HResultCallback& callback);
   void RegisterGattCharacteristicValueChangedEvent(
       base::FilePath service_path,

device/bluetooth/bluez/bluetooth_remote_gatt_characteristic_bluez.cc

@@ -24,6 +24,7 @@
 #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/bluetooth/dbus-constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
@@ -171,6 +172,36 @@ void BluetoothRemoteGattCharacteristicBlueZ::ReadRemoteCharacteristic(
                          std::move(error_callback)));
 }
 
+void BluetoothRemoteGattCharacteristicBlueZ::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
+  DVLOG(1) << "Sending GATT characteristic write request to characteristic: "
+           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value()
+           << ", with value: " << value << ", with response: "
+           << ((write_type == WriteType::kWithoutResponse) ? "no" : "yes")
+           << ".";
+
+  const char* type_option;
+  switch (write_type) {
+    case WriteType::kWithResponse:
+      type_option = bluetooth_gatt_characteristic::kTypeRequest;
+      break;
+    case WriteType::kWithoutResponse:
+      type_option = bluetooth_gatt_characteristic::kTypeCommand;
+      break;
+  }
+
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothGattCharacteristicClient()
+      ->WriteValue(
+          object_path(), value, type_option, std::move(callback),
+          base::BindOnce(&BluetoothRemoteGattCharacteristicBlueZ::OnWriteError,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         std::move(error_callback)));
+}
+
 void BluetoothRemoteGattCharacteristicBlueZ::
     DeprecatedWriteRemoteCharacteristic(const std::vector<uint8_t>& value,
                                         base::OnceClosure callback,
@@ -182,7 +213,7 @@ void BluetoothRemoteGattCharacteristicBlueZ::
   bluez::BluezDBusManager::Get()
       ->GetBluetoothGattCharacteristicClient()
       ->WriteValue(
-          object_path(), value, std::move(callback),
+          object_path(), value, "", std::move(callback),
           base::BindOnce(&BluetoothRemoteGattCharacteristicBlueZ::OnWriteError,
                          weak_ptr_factory_.GetWeakPtr(),
                          std::move(error_callback)));

device/bluetooth/bluez/bluetooth_remote_gatt_characteristic_bluez.h

@@ -56,6 +56,10 @@ class BluetoothRemoteGattCharacteristicBlueZ
   bool IsNotifying() const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,

device/bluetooth/cast/bluetooth_remote_gatt_characteristic_cast.cc

@@ -14,6 +14,7 @@
 #include "base/memory/weak_ptr.h"
 #include "chromecast/device/bluetooth/le/remote_characteristic.h"
 #include "chromecast/device/bluetooth/le/remote_descriptor.h"
+#include "chromecast/public/bluetooth/gatt.h"
 #include "device/bluetooth/cast/bluetooth_remote_gatt_descriptor_cast.h"
 #include "device/bluetooth/cast/bluetooth_remote_gatt_service_cast.h"
 #include "device/bluetooth/cast/bluetooth_utils.h"
@@ -141,6 +142,32 @@ void BluetoothRemoteGattCharacteristicCast::ReadRemoteCharacteristic(
       std::move(error_callback)));
 }
 
+void BluetoothRemoteGattCharacteristicCast::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
+  using ChromecastWriteType = chromecast::bluetooth_v2_shlib::Gatt::WriteType;
+
+  ChromecastWriteType chromecast_write_type;
+  switch (write_type) {
+    case WriteType::kWithResponse:
+      chromecast_write_type = ChromecastWriteType::WRITE_TYPE_DEFAULT;
+      break;
+    case WriteType::kWithoutResponse:
+      chromecast_write_type = ChromecastWriteType::WRITE_TYPE_NO_RESPONSE;
+      break;
+  }
+
+  remote_characteristic_->WriteAuth(
+      chromecast::bluetooth_v2_shlib::Gatt::Client::AUTH_REQ_NONE,
+      chromecast_write_type, value,
+      base::BindOnce(
+          &BluetoothRemoteGattCharacteristicCast::OnWriteRemoteCharacteristic,
+          weak_factory_.GetWeakPtr(), value, std::move(callback),
+          std::move(error_callback)));
+}
+
 void BluetoothRemoteGattCharacteristicCast::DeprecatedWriteRemoteCharacteristic(
     const std::vector<uint8_t>& value,
     base::OnceClosure callback,

device/bluetooth/cast/bluetooth_remote_gatt_characteristic_cast.h

@@ -47,6 +47,10 @@ class BluetoothRemoteGattCharacteristicCast
   BluetoothRemoteGattService* GetService() const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,

device/bluetooth/dbus/bluetooth_gatt_characteristic_client.cc

@@ -14,6 +14,7 @@
 #include "dbus/bus.h"
 #include "dbus/object_manager.h"
 #include "dbus/values_util.h"
+#include "third_party/cros_system_api/dbus/bluetooth/dbus-constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
@@ -113,6 +114,7 @@ class BluetoothGattCharacteristicClientImpl
   // BluetoothGattCharacteristicClient override.
   void WriteValue(const dbus::ObjectPath& object_path,
                   const std::vector<uint8_t>& value,
+                  base::StringPiece type_option,
                   base::OnceClosure callback,
                   ErrorCallback error_callback) override {
     dbus::ObjectProxy* object_proxy =
@@ -128,8 +130,14 @@ class BluetoothGattCharacteristicClientImpl
     dbus::MessageWriter writer(&method_call);
     writer.AppendArrayOfBytes(value.data(), value.size());
 
-    // Append empty option dict
+    // Append option dict
     base::DictionaryValue dict;
+    if (!type_option.empty()) {
+      // NB: the "type" option was added in BlueZ 5.50. Older versions of BlueZ
+      // will ignore this option.
+      dict.SetStringKey(bluetooth_gatt_characteristic::kOptionType,
+                        type_option);
+    }
     dbus::AppendValueData(&writer, dict);
 
     object_proxy->CallMethodWithErrorCallback(

device/bluetooth/dbus/bluetooth_gatt_characteristic_client.h

@@ -105,10 +105,12 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothGattCharacteristicClient
                          ErrorCallback error_callback) = 0;
 
   // Issues a request to write the value of GATT characteristic with object path
-  // |object_path| with value |value|. Invokes |callback| on success and
-  // |error_callback| on failure.
+  // |object_path| with value |value| and |type_option|. |type_option| is
+  // bluetooth_gatt_characteristic::kTypeRequest or kTypeCommand, or "" to omit
+  // the option. Invokes |callback| on success and |error_callback| on failure.
   virtual void WriteValue(const dbus::ObjectPath& object_path,
                           const std::vector<uint8_t>& value,
+                          base::StringPiece type_option,
                           base::OnceClosure callback,
                           ErrorCallback error_callback) = 0;
 

device/bluetooth/dbus/fake_bluetooth_device_client.cc

@@ -649,8 +649,10 @@ void FakeBluetoothDeviceClient::ExecuteWrite(
   for (const auto& prepare_write_request : prepare_write_requests_) {
     bluez::BluezDBusManager::Get()
         ->GetBluetoothGattCharacteristicClient()
-        ->WriteValue(prepare_write_request.first, prepare_write_request.second,
-                     base::DoNothing(), base::DoNothing());
+        ->WriteValue(std::get<0>(prepare_write_request),
+                     std::get<1>(prepare_write_request),
+                     std::get<2>(prepare_write_request), base::DoNothing(),
+                     base::DoNothing());
   }
   prepare_write_requests_.clear();
   std::move(callback).Run();

device/bluetooth/dbus/fake_bluetooth_device_client.h

@@ -384,7 +384,7 @@ class DEVICE_BLUETOOTH_EXPORT FakeBluetoothDeviceClient
   bool delay_start_discovery_;
 
   // Pending prepare write requests.
-  std::vector<std::pair<dbus::ObjectPath, std::vector<uint8_t>>>
+  std::vector<std::tuple<dbus::ObjectPath, std::vector<uint8_t>, std::string>>
       prepare_write_requests_;
 
   bool should_leave_connections_pending_;

device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.cc

@@ -206,6 +206,7 @@ void FakeBluetoothGattCharacteristicClient::ReadValue(
 void FakeBluetoothGattCharacteristicClient::WriteValue(
     const dbus::ObjectPath& object_path,
     const std::vector<uint8_t>& value,
+    base::StringPiece type_option,
     base::OnceClosure callback,
     ErrorCallback error_callback) {
   if (!authenticated_) {

device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.h

@@ -57,6 +57,7 @@ class DEVICE_BLUETOOTH_EXPORT FakeBluetoothGattCharacteristicClient
                  ErrorCallback error_callback) override;
   void WriteValue(const dbus::ObjectPath& object_path,
                   const std::vector<uint8_t>& value,
+                  base::StringPiece type_option,
                   base::OnceClosure callback,
                   ErrorCallback error_callback) override;
   void PrepareWriteValue(const dbus::ObjectPath& object_path,

device/bluetooth/test/android/java/src/org/chromium/device/bluetooth/Fakes.java

@@ -693,6 +693,7 @@ class Fakes {
         final int mProperties;
         final UUID mUuid;
         byte[] mValue;
+        int mWriteType;
         static FakeBluetoothGattCharacteristic sRememberedCharacteristic;
         final ArrayList<Wrappers.BluetoothGattDescriptorWrapper> mDescriptors;
 
@@ -846,6 +847,11 @@ class Fakes {
             mValue = value;
             return true;
         }
+
+        @Override
+        public void setWriteType(int writeType) {
+            mWriteType = writeType;
+        }
     }
 
     /**

device/bluetooth/test/fake_remote_gatt_characteristic.cc

@@ -138,6 +138,28 @@ void FakeRemoteGattCharacteristic::ReadRemoteCharacteristic(
                      std::move(error_callback)));
 }
 
+void FakeRemoteGattCharacteristic::WriteRemoteCharacteristic(
+    const std::vector<uint8_t>& value,
+    WriteType write_type,
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
+  // It doesn't make sense to dispatch a custom write response if the
+  // characteristic only supports write without response but we still need to
+  // run the callback because that's the guarantee the API makes.
+  if (write_type == WriteType::kWithoutResponse) {
+    last_written_value_ = value;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  std::move(callback));
+    return;
+  }
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&FakeRemoteGattCharacteristic::DispatchWriteResponse,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback),
+                     std::move(error_callback), value));
+}
+
 void FakeRemoteGattCharacteristic::DeprecatedWriteRemoteCharacteristic(
     const std::vector<uint8_t>& value,
     base::OnceClosure callback,

device/bluetooth/test/fake_remote_gatt_characteristic.h

@@ -85,6 +85,10 @@ class FakeRemoteGattCharacteristic
   device::BluetoothRemoteGattService* GetService() const override;
   void ReadRemoteCharacteristic(ValueCallback callback,
                                 ErrorCallback error_callback) override;
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& value,
+                                 WriteType write_type,
+                                 base::OnceClosure callback,
+                                 ErrorCallback error_callback) override;
   void DeprecatedWriteRemoteCharacteristic(
       const std::vector<uint8_t>& value,
       base::OnceClosure callback,

device/bluetooth/test/mock_bluetooth_gatt_characteristic.h

@@ -74,6 +74,17 @@ class MockBluetoothGattCharacteristic
     ReadRemoteCharacteristic_(c, ec);
   }
   MOCK_METHOD2(ReadRemoteCharacteristic_, void(ValueCallback&, ErrorCallback&));
+  void WriteRemoteCharacteristic(const std::vector<uint8_t>& v,
+                                 WriteType t,
+                                 base::OnceClosure c,
+                                 ErrorCallback ec) override {
+    WriteRemoteCharacteristic_(v, t, c, ec);
+  }
+  MOCK_METHOD4(WriteRemoteCharacteristic_,
+               void(const std::vector<uint8_t>&,
+                    WriteType,
+                    base::OnceClosure&,
+                    ErrorCallback&));
   void DeprecatedWriteRemoteCharacteristic(const std::vector<uint8_t>& v,
                                            base::OnceClosure c,
                                            ErrorCallback ec) override {