[Clean up] Expose ConnectToServiceInsecurely as a BluetoothDevice API on all platforms.

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 <map>
 #include <string>
 #include <vector>
@@ skipping 338 matching lines @@
   // cause.
   typedef base::Callback<void(scoped_refptr<BluetoothSocket>)>
       ConnectToServiceCallback;
   typedef base::Callback<void(const std::string& message)>
       ConnectToServiceErrorCallback;
   virtual void ConnectToService(
       const BluetoothUUID& uuid,
       const ConnectToServiceCallback& callback,
       const ConnectToServiceErrorCallback& error_callback) = 0;
 
+  // Attempts to initiate an insecure outgoing L2CAP or RFCOMM connection to the
+  // advertised service on this device matching |uuid|, performing an SDP lookup
+  // if necessary to determine the correct protocol and channel for the
+  // connection. Unlike ConnectToService, the outgoing connection will request
+  // no bonding rather than general bonding. |callback| will be called on a
+  // successful connection with a BluetoothSocket instance that is to be owned
+  // by the receiver. |error_callback| will be called on failure with a message
+  // indicating the cause.
+  virtual void ConnectToServiceInsecurely(
+    const device::BluetoothUUID& uuid,
+    const ConnectToServiceCallback& callback,
+    const ConnectToServiceErrorCallback& error_callback) = 0;

[armansito, 2014/10/15 19:02:16]

Kind of tangential to this CL, though I wonder why ConnectToServiceErrorCallback
doesn't return (in an argument) an enum ConnectErrorCode. It's strange that we
have different signatures for Connect and ConnectToService*. Perhaps add a TODO
for this, if what I'm saying makes sense to you.

[Ilya Sherman, 2014/10/15 22:04:45]

I personally find the strings more convenient than an enum, since most code that
handles connection failures doesn't really treat different failure reasons
differently, other than maybe logging the failure reason.  I'm therefore going
to omit the TODO, since I think it's worth discussing a bit more to figure out
what behavior we want, exactly.  In general, though, making Connect and
ConnectToService* have roughly the same signature makes sense to me.

+
   // Opens a new GATT connection to this device. On success, a new
   // BluetoothGattConnection will be handed to the caller via |callback|. On
   // error, |error_callback| will be called. The connection will be kept alive,
   // as long as there is at least one active GATT connection. In the case that
   // the underlying connection gets terminated, either due to a call to
   // BluetoothDevice::Disconnect or other unexpected circumstances, the
   // returned BluetoothGattConnection will be automatically marked as inactive.
   // To monitor the state of the connection, observe the
   // BluetoothAdapter::Observer::DeviceChanged method.
   typedef base::Callback<void(scoped_ptr<BluetoothGattConnection>)>
@@ skipping 34 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_