Prototype for copresenceSockets.

components/copresence_sockets/copresence_peer.cc

Index: components/copresence_sockets/copresence_peer.cc
diff --git a/components/copresence_sockets/copresence_peer.cc b/components/copresence_sockets/copresence_peer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0733e7e64f9fd19191ef90125eb211e79ef9473f
--- /dev/null
+++ b/components/copresence_sockets/copresence_peer.cc
@@ -0,0 +1,152 @@
+// Copyright 2014 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 "components/copresence_sockets/public/copresence_peer.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "components/copresence_sockets/mediums/bluetooth/copresence_socket_bluetooth.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_device.h"
+#include "device/bluetooth/bluetooth_socket.h"
+#include "device/bluetooth/bluetooth_uuid.h"
+
+namespace {
+
+std::string RandomHexBytes(size_t length) {
+  static const char kHexChars[] = "0123456789ABCDEF";
+
+  std::string rand_string;
+  for (size_t i = 0; i < length; ++i)
+    rand_string += kHexChars[base::RandInt(0, 15)];
+  return rand_string;
+}
+
+device::BluetoothUUID GenerateRandomUuid() {
+  // Random hex string of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+  return device::BluetoothUUID(RandomHexBytes(8) + "-" + RandomHexBytes(4) +

[Ken Rockot(use gerrit already), 2014/09/30 17:26:04]

nit: Use StringPrintf instead?

[rkc, 2014/10/01 19:08:23]

Done.

+                               "-" + RandomHexBytes(4) + "-" +
+                               RandomHexBytes(4) + "-" + RandomHexBytes(12));
+}
+
+class DefaultApprovalDelegate
+    : public device::BluetoothDevice::PairingDelegate {
+ public:
+  DefaultApprovalDelegate() {}
+  virtual ~DefaultApprovalDelegate() {}
+
+  // device::PairingDelegate overrides:

[Ken Rockot(use gerrit already), 2014/09/30 17:26:04]

nit: device::BluetoothDevice::PairingDelegate

[rkc, 2014/10/01 19:08:23]

Done.

+  virtual void RequestPinCode(device::BluetoothDevice* device) override {}
+  virtual void RequestPasskey(device::BluetoothDevice* device) override {}
+  virtual void DisplayPinCode(device::BluetoothDevice* device,
+                              const std::string& pincode) override {}
+  virtual void DisplayPasskey(device::BluetoothDevice* device,
+                              uint32 passkey) override {}
+  virtual void KeysEntered(device::BluetoothDevice* device,
+                           uint32 entered) override {}
+  virtual void ConfirmPasskey(device::BluetoothDevice* device,
+                              uint32 passkey) override {}
+  virtual void AuthorizePairing(device::BluetoothDevice* device) override {
+    if (device->ExpectingConfirmation())
+      device->ConfirmPairing();
+  }
+};
+
+}  // namespace
+
+namespace copresence_sockets {
+
+// Public methods.
+
+CopresencePeer::CopresencePeer(CreatePeerCallback create_callback,
+                               AcceptCallback accept_callback)
+    : create_callback_(create_callback),
+      accept_callback_(accept_callback),

[armansito, 2014/09/30 20:37:58]

It looks like |accept_callback_| and |create_callback_| get called as part of
the instantiation sequence, so wouldn't it be better to just pass them on as
callback parameters instead of caching them as members?

[rkc, 2014/10/01 19:08:23]

I had it that way earlier, but it seemed simpler to simply cache them in the
object, than to bind them to every single call made during instantiation (and
having to add 2 parameters to every "OnXXX" method.

+      delegate_(nullptr) {
+  DCHECK(!create_callback.is_null());
+  DCHECK(!accept_callback.is_null());
+
+  if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
+    create_callback_.Run(std::string());
+    return;
+  }
+
+  device::BluetoothAdapterFactory::GetAdapter(
+      base::Bind(&CopresencePeer::OnGetAdapter, AsWeakPtr()));

[Ken Rockot(use gerrit already), 2014/09/30 17:26:04]

Here and elsewhere it looks like you only use a WeakPtr<T> inside of T's
implementation. In this case composing a WeakPtrFactory into T is preferred over
inheriting SupportsWeakPtr<T>.

[rkc, 2014/10/01 19:08:23]

Done.

+}
+
+std::string CopresencePeer::GetLocatorData() {
+  // TODO(rkc): Fix the "1." once we have finalized the locator format with
+  // other platforms.
+  return "1." + adapter_->GetAddress() + "." + service_uuid_.value();
+}
+
+CopresencePeer::~CopresencePeer() {
+  server_socket_->Disconnect(base::Bind(&base::DoNothing));
+  server_socket_->Close();
+  if (delegate_) {
+    adapter_->RemovePairingDelegate(delegate_);
+    delete delegate_;
+  }
+}
+
+// Private methods.
+
+void CopresencePeer::OnGetAdapter(
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+  if (!adapter.get()) {
+    create_callback_.Run(std::string());
+    return;
+  }
+
+  adapter_ = adapter;
+  service_uuid_ = GenerateRandomUuid();

[armansito, 2014/09/30 20:37:58]

I'm not sure about using a random UUID here. If the UUID is random, how will the
remote end know to connect to this UUID? Instead, you should probably establish
a special UUID for the Bluetooth service that you're building and consistently
use that. That UUID would basically represent the "Copresence Bluetooth Socket
Service".

[rkc, 2014/10/01 19:08:23]

This is how the Android side is currently implemented. I believe there are some
security reasons for this. I'll speak with the Android team and see if we can
use a fixed UUID instead. Once their side also does that, I'll update this code.

We need to pass the locator data to the other side anyway for communications to
get setup; the service UUID also goes part of that data.

+
+  delegate_ = new DefaultApprovalDelegate();
+  VLOG(2) << "Creating service with UUID: " << service_uuid_.value();
+  adapter_->AddPairingDelegate(
+      delegate_, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+  adapter_->CreateRfcommService(
+      service_uuid_,
+      device::BluetoothAdapter::ServiceOptions(),
+      base::Bind(&CopresencePeer::OnCreateService, AsWeakPtr()),
+      base::Bind(&CopresencePeer::OnCreateServiceError, AsWeakPtr()));
+}
+
+void CopresencePeer::OnCreateService(
+    scoped_refptr<device::BluetoothSocket> socket) {
+  if (!socket.get()) {
+    create_callback_.Run(std::string());
+    return;
+  }
+
+  server_socket_ = socket;
+  create_callback_.Run(GetLocatorData());
+  server_socket_->Accept(
+      base::Bind(&CopresencePeer::OnAccept, AsWeakPtr()),
+      base::Bind(&CopresencePeer::OnAcceptError, AsWeakPtr()));
+}
+
+void CopresencePeer::OnCreateServiceError(const std::string& message) {
+  LOG(WARNING) << "Couldn't create Bluetooth service: " << message;
+  create_callback_.Run(std::string());
+}
+
+void CopresencePeer::OnAccept(const device::BluetoothDevice* device,
+                              scoped_refptr<device::BluetoothSocket> socket) {
+  if (!socket.get())
+    return;
+  CopresenceSocketBluetooth* copresence_socket =
+      new CopresenceSocketBluetooth(socket);
+  accept_callback_.Run(copresence_socket);
+}
+
+void CopresencePeer::OnAcceptError(const std::string& message) {
+  LOG(WARNING) << "Couldn't accept Bluetooth connection: " << message;
+}
+
+}  // namespace copresence_sockets