bluetooth: Return int8_t and use -128 for unknown tx power.

device/bluetooth/bluetooth_device.h

 // Copyright (c) 2012 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/optional.h"
 #include "base/strings/string16.h"
 #include "device/bluetooth/bluetooth_export.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "net/log/net_log.h"
 
 namespace base {
 class BinaryValue;
 }
 
 namespace device {
@@ skipping 40 matching lines @@
     DEVICE_VIDEO,
     DEVICE_PERIPHERAL,
     DEVICE_JOYSTICK,
     DEVICE_GAMEPAD,
     DEVICE_KEYBOARD,
     DEVICE_MOUSE,
     DEVICE_TABLET,
     DEVICE_KEYBOARD_MOUSE_COMBO
   };
 
-  // The value returned if the RSSI or transmit power cannot be read.
-  static const int kUnknownPower = 127;
   // The value returned if the appearance is not present.
   static const uint16_t kAppearanceNotPresent = 0xffc0;
 
   struct DEVICE_BLUETOOTH_EXPORT ConnectionInfo {
-    int rssi;
-    int transmit_power;
-    int max_transmit_power;
+    base::Optional<int8_t> rssi;
+    base::Optional<int8_t> transmit_power;
+    base::Optional<int8_t> max_transmit_power;
 
     ConnectionInfo();
-    ConnectionInfo(int rssi, int transmit_power, int max_transmit_power);
+    ConnectionInfo(const base::Optional<int8_t>& rssi,
+                   const base::Optional<int8_t>& transmit_power,
+                   const base::Optional<int8_t>& max_transmit_power);
     ~ConnectionInfo();
   };
 
   // Possible errors passed back to an error callback function in case of a
   // failed call to Connect().
   enum ConnectErrorCode {
     ERROR_ATTRIBUTE_LENGTH_INVALID,
     ERROR_AUTH_CANCELED,
     ERROR_AUTH_FAILED,
     ERROR_AUTH_REJECTED,
@@ skipping 174 matching lines @@
   // such as vendor and product id.
   bool IsTrustable() const;
 
   // Returns the set of UUIDs that this device supports. For classic Bluetooth
   // devices this data is collected from both the EIR data and SDP tables,
   // for Low Energy devices this data is collected from AD and GATT primary
   // services, for dual mode devices this may be collected from both./
   virtual UUIDList GetUUIDs() const = 0;
 
   // The received signal strength, in dBm. This field is avaliable and valid
-  // only during discovery. If not during discovery, or RSSI wasn't reported,
-  // this method will return |kUnknownPower|.
-  virtual int16_t GetInquiryRSSI() const = 0;
+  // only during discovery. If not during discovery, or RSSI wasn't reported
+  // this value will be absent.
+  virtual base::Optional<int8_t> GetInquiryRSSI() const = 0;
 
   // The transmitted power level. This field is avaliable only for LE devices
   // that include this field in AD. It is avaliable and valid only during
   // discovery. If not during discovery, or TxPower wasn't reported, this
-  // method will return |kUnknownPower|.
-  virtual int16_t GetInquiryTxPower() const = 0;
+  // value will be absent.
+  virtual base::Optional<int8_t> GetInquiryTxPower() const = 0;
 
   // The ErrorCallback is used for methods that can fail in which case it
   // is called, in the success case the callback is simply not called.
   typedef base::Callback<void()> ErrorCallback;
 
   // The ConnectErrorCallback is used for methods that can fail with an error,
   // passed back as an error code argument to this callback.
   // In the success case this callback is not called.
   typedef base::Callback<void(enum ConnectErrorCode)> ConnectErrorCallback;
 
@@ skipping 16 matching lines @@
   // The RSSI indicates the power present in the received radio signal, measured
   // in dBm, to a resolution of 1dBm. Larger (typically, less negative) values
   // indicate a stronger signal.
   //
   // The transmit power indicates the strength of the signal broadcast from the
   // host's Bluetooth antenna when communicating with the device, measured in
   // dBm, to a resolution of 1dBm. Larger (typically, less negative) values
   // indicate a stronger signal.
   //
   // If the device isn't connected, then the ConnectionInfo struct passed into
-  // the callback will be populated with |kUnknownPower|.
+  // the callback will be populated with absent values.
   virtual void GetConnectionInfo(const ConnectionInfoCallback& callback) = 0;
 
   // Initiates a connection to the device, pairing first if necessary.
   //
   // Method calls will be made on the supplied object |pairing_delegate|
   // to indicate what display, and in response should make method calls
   // back to the device object. Not all devices require user responses
   // during pairing, so it is normal for |pairing_delegate| to receive no
   // calls. To explicitly force a low-security connection without bonding,
   // pass NULL, though this is ignored if the device is already paired.
@@ skipping 210 matching lines @@
 
  private:
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_