bluetooth: Add control for reading/writing of descriptor values to internals page.

chrome/browser/resources/bluetooth_internals/value_control.js

 // Copyright 2017 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.
 
 /**
  * Javascript for ValueControl, served from chrome://bluetooth-internals/.
  */
 
 cr.define('value_control', function() {
   /** @const */ var Snackbar = snackbar.Snackbar;
   /** @const */ var SnackbarType = snackbar.SnackbarType;
 
+  /** @typedef {{
+   *    deviceAddress: string,
+   *    serviceId: string,
+   *    characteristicId: string,
+   *    descriptorId: (string|undefined)
+   *    properties: (number|undefined)
+   *  }}
+   */
+  var ValueLoadOptions;
+
   /** @enum {string}  */
   var ValueDataType = {
     HEXADECIMAL: 'Hexadecimal',
     UTF8: 'UTF-8',
     DECIMAL: 'Decimal',
   };
 
   /**
    * A container for an array value that needs to be converted to multiple
    * display formats. Internally, the value is stored as an array and converted
@@ skipping 180 matching lines @@
      */
     decorate: function() {
       this.classList.add('value-control');
 
       /** @private {!Value} */
       this.value_ = new Value([]);
       /** @private {?string} */
       this.deviceAddress_ = null;
       /** @private {?string} */
       this.serviceId_ = null;
-      /** @private {?interfaces.BluetoothDevice.CharacteristicInfo} */
-      this.characteristicInfo_ = null;
+      /** @private {?string} */
+      this.characteristicId_ = null;
+      /** @private {?string} */
+      this.descriptorId_ = null;
+      /** @private {number} */
+      this.properties_ = Number.MAX_SAFE_INTEGER;
 
       this.unavailableMessage_ = document.createElement('h3');
       this.unavailableMessage_.textContent = 'Value cannot be read or written.';
 
       this.valueInput_ = document.createElement('input');
       this.valueInput_.addEventListener('change', function() {
         try {
           this.value_.setAs(this.typeSelect_.value, this.valueInput_.value);
         } catch (e) {
           Snackbar.show(e.message, SnackbarType.ERROR);
@@ skipping 28 matching lines @@
       buttonsDiv.appendChild(this.readBtn_);
       buttonsDiv.appendChild(this.writeBtn_);
 
       this.appendChild(this.unavailableMessage_);
       this.appendChild(inputDiv);
       this.appendChild(buttonsDiv);
     },
 
     /**
      * Sets the settings used by the value control and redraws the control to
-     * match the read/write settings provided in
-     * |characteristicInfo.properties|.
-     * @param {string} deviceAddress
-     * @param {string} serviceId
-     * @param {!interfaces.BluetoothDevice.CharacteristicInfo}
-     *     characteristicInfo
+     * match the read/write settings in |options.properties|. If properties
+     * are not provided, no restrictions on reading/writing are applied.
+     * @param {!ValueLoadOptions} options
      */
-    load: function(deviceAddress, serviceId, characteristicInfo) {
-      this.deviceAddress_ = deviceAddress;
-      this.serviceId_ = serviceId;
-      this.characteristicInfo_ = characteristicInfo;
+    load: function(options) {
+      this.deviceAddress_ = options.deviceAddress;
+      this.serviceId_ = options.serviceId;
+      this.characteristicId_ = options.characteristicId;
+      this.descriptorId_ = options.descriptorId;
+
+      if (options.properties)
+        this.properties_ = options.properties;
 
       this.redraw();
     },
 
     /**
      * Redraws the value control with updated layout depending on the
      * availability of reads and writes and the current cached value.
      */
     redraw: function() {
-      this.readBtn_.hidden = (this.characteristicInfo_.properties &
-                              interfaces.BluetoothDevice.Property.READ) === 0;
-      this.writeBtn_.hidden = (this.characteristicInfo_.properties &
-                               interfaces.BluetoothDevice.Property.WRITE) === 0;
+      this.readBtn_.hidden =
+          (this.properties_ & interfaces.BluetoothDevice.Property.READ) === 0;
+      this.writeBtn_.hidden =
+          (this.properties_ & interfaces.BluetoothDevice.Property.WRITE) === 0;
 
       var isAvailable = !this.readBtn_.hidden || !this.writeBtn_.hidden;
       this.unavailableMessage_.hidden = isAvailable;
       this.valueInput_.hidden = !isAvailable;
       this.typeSelect_.hidden = !isAvailable;
 
       if (!isAvailable)
         return;
 
       this.valueInput_.value = this.value_.getAs(this.typeSelect_.value);
@@ skipping 18 matching lines @@
       // messages.
       var GattResult = interfaces.BluetoothDevice.GattResult;
       return Object.keys(GattResult).find(function(key) {
         return GattResult[key] === result;
       });
     },
 
     /**
      * Called when the read button is pressed. Connects to the device and
      * retrieves the current value of the characteristic in the |service_id|
-     * with id |characteristic_id|
+     * with id |characteristic_id|. If |descriptor_id| is defined,  the
+     * descriptor value with |descriptor_id| is read instead.
      * @private
      */
     readValue_: function() {
       this.readBtn_.disabled = true;
 
       device_broker.connectToDevice(this.deviceAddress_).then(function(device) {
+        if (this.descriptorId_) {
+          return device.readValueForDescriptor(
+              this.serviceId_, this.characteristicId_, this.descriptorId_);
+        }
+
         return device.readValueForCharacteristic(
-            this.serviceId_, this.characteristicInfo_.id);
+            this.serviceId_, this.characteristicId_);
       }.bind(this)).then(function(response) {
         this.readBtn_.disabled = false;
 
         if (response.result === interfaces.BluetoothDevice.GattResult.SUCCESS) {
           this.setValue(response.value);
           Snackbar.show(
               this.deviceAddress_ + ': Read succeeded', SnackbarType.SUCCESS);
           return;
         }
 
         var errorString = this.getErrorString_(response.result);
         Snackbar.show(
             this.deviceAddress_ + ': ' + errorString, SnackbarType.ERROR,
             'Retry', this.readValue_.bind(this));
       }.bind(this));
     },
 
     /**
      * Called when the write button is pressed. Connects to the device and
-     * retrieves the current value of the characteristic in the |service_id|
-     * with id |characteristic_id|
+     * retrieves the current value of the characteristic in the
+     * |service_id| with id |characteristic_id|. If |descriptor_id| is defined,
+     * the descriptor value with |descriptor_id| is written instead.
      * @private
      */
     writeValue_: function() {
       this.writeBtn_.disabled = true;
 
       device_broker.connectToDevice(this.deviceAddress_).then(function(device) {
+        if (this.descriptorId_) {
+          return device.writeValueForDescriptor(
+              this.serviceId_, this.characteristicId_, this.descriptorId_,
+              this.value_.getArray());
+        }
+
         return device.writeValueForCharacteristic(
-            this.serviceId_, this.characteristicInfo_.id,
-            this.value_.getArray());
+            this.serviceId_, this.characteristicId_, this.value_.getArray());
       }.bind(this)).then(function(response) {
         this.writeBtn_.disabled = false;
 
         if (response.result === interfaces.BluetoothDevice.GattResult.SUCCESS) {
           Snackbar.show(
               this.deviceAddress_ + ': Write succeeded', SnackbarType.SUCCESS);
           return;
         }
 
         var errorString = this.getErrorString_(response.result);
         Snackbar.show(
             this.deviceAddress_ + ': ' + errorString, SnackbarType.ERROR,
             'Retry', this.writeValue_.bind(this));
       }.bind(this));
     },
   }
 
   return {
     ValueControl: ValueControl,
     ValueDataType: ValueDataType,
   };
 });