arc: bluetooth: Clean up arc_bluetooth_bridge

components/arc/bluetooth/arc_bluetooth_bridge.cc

 // Copyright 2016 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/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <bluetooth/bluetooth.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 63 matching lines @@
 constexpr int32_t kMaxGattAttributeHandle = 0xFFFF;
 // Bluetooth Specification Version 4.2 Vol 3 Part F Section 3.2.9
 // The maximum length of an attribute value shall be 512 octets.
 constexpr int kMaxGattAttributeLength = 512;
 // Copied from Android at system/bt/stack/btm/btm_ble_int.h
 // https://goo.gl/k7PM6u
 constexpr uint16_t kAndroidMBluetoothVersionNumber = 95;
 constexpr uint16_t kMaxAdvertisement = 5;
 // Bluetooth SDP Service Class ID List Attribute identifier
 constexpr uint16_t kServiceClassIDListAttributeID = 0x0001;
+// Timeout for Bluetooth Discovery (scan)
+constexpr base::TimeDelta kDiscoveryTimeout = base::TimeDelta::FromSeconds(120);

[Rahul Chaturvedi, 2016/09/21 22:40:26]

Mention in comment why 2 minutes.

[puthik_chromium, 2016/09/22 00:26:55]

Done.

+// From https://www.bluetooth.com/specifications/assigned-numbers/baseband
+// The Class of Device for generic computer.
+constexpr uint32_t kBluetoothComputerClass = 0x100;
 
 using GattStatusCallback =
     base::Callback<void(arc::mojom::BluetoothGattStatus)>;
 using GattReadCallback =
     base::Callback<void(arc::mojom::BluetoothGattValuePtr)>;
 using CreateSdpRecordCallback =
     base::Callback<void(arc::mojom::BluetoothCreateSdpRecordResultPtr)>;
 using RemoveSdpRecordCallback =
     base::Callback<void(arc::mojom::BluetoothStatus)>;
 
@@ skipping 209 matching lines @@
   // ready, we should register it now.
   if (bluetooth_adapter_ && !bluetooth_adapter_->HasObserver(this))
     bluetooth_adapter_->AddObserver(this);
 }
 
 void ArcBluetoothBridge::OnInstanceClosed() {
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
-void ArcBluetoothBridge::AdapterPoweredChanged(BluetoothAdapter* adapter,
-                                               bool powered) {
-  // TODO(smbarber): Invoke EnableAdapter or DisableAdapter via ARC bridge
-  // service.
-}
-
 void ArcBluetoothBridge::DeviceAdded(BluetoothAdapter* adapter,
                                      BluetoothDevice* device) {
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnDeviceFound");
   if (!bluetooth_instance)
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
@@ skipping 472 matching lines @@
 void ArcBluetoothBridge::SetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnRemoteDeviceProperties");
   if (!bluetooth_instance)
     return;
 
-  // TODO(smbarber): Implement SetRemoteDeviceProperty
+  // Unsupported. Only used by Android hidden API, BluetoothDevice.SetAlias().
+  // And only Android Settings App / Android TV / NFC used that.
   bluetooth_instance->OnRemoteDeviceProperties(
-      mojom::BluetoothStatus::FAIL, std::move(remote_addr),
+      mojom::BluetoothStatus::UNSUPPORTED, std::move(remote_addr),
       mojo::Array<mojom::BluetoothPropertyPtr>::New(0));
 }
 
 void ArcBluetoothBridge::GetRemoteServiceRecord(
     mojom::BluetoothAddressPtr remote_addr,
     const BluetoothUUID& uuid) {
   // TODO(smbarber): Implement GetRemoteServiceRecord
 }
 
 void ArcBluetoothBridge::GetRemoteServices(
     mojom::BluetoothAddressPtr remote_addr) {
   // TODO(smbarber): Implement GetRemoteServices
 }
 
 void ArcBluetoothBridge::StartDiscovery() {
   DCHECK(bluetooth_adapter_);
-  // TODO(smbarber): Add timeout
+  DCHECK(CalledOnValidThread());
+
   if (discovery_session_) {
-    LOG(ERROR) << "Discovery session already running; leaving alone";
+    LOG(ERROR) << "Discovery session already running; Reset timeout.";
+    discovery_off_timer_.Start(FROM_HERE, kDiscoveryTimeout,
+                               base::Bind(&ArcBluetoothBridge::CancelDiscovery,
+                                          weak_factory_.GetWeakPtr()));
     SendCachedDevicesFound();
     return;
   }
 
   bluetooth_adapter_->StartDiscoverySession(
       base::Bind(&ArcBluetoothBridge::OnDiscoveryStarted,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ArcBluetoothBridge::OnDiscoveryError,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 24 matching lines @@
     const base::Callback<void(mojom::BluetoothAdapterState)>& callback) const {
   LOG(WARNING) << "failed to change power state";
 
   callback.Run(bluetooth_adapter_->IsPowered()
                    ? mojom::BluetoothAdapterState::ON
                    : mojom::BluetoothAdapterState::OFF);
 }
 
 void ArcBluetoothBridge::OnDiscoveryStarted(
     std::unique_ptr<BluetoothDiscoverySession> session) {
+  DCHECK(CalledOnValidThread());
+
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnDiscoveryStateChanged");
   if (!bluetooth_instance)
     return;
 
   discovery_session_ = std::move(session);
 
+  discovery_off_timer_.Start(FROM_HERE, kDiscoveryTimeout,
+                             base::Bind(&ArcBluetoothBridge::CancelDiscovery,
+                                        weak_factory_.GetWeakPtr()));
+
   bluetooth_instance->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STARTED);
 
   SendCachedDevicesFound();
 }
 
 void ArcBluetoothBridge::OnDiscoveryStopped() {
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnDiscoveryStateChanged");
   if (!bluetooth_instance)
     return;
 
   discovery_session_.reset();
+  discovery_off_timer_.Stop();
 
   bluetooth_instance->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STOPPED);
 }
 
 void ArcBluetoothBridge::CreateBond(mojom::BluetoothAddressPtr addr,
                                     int32_t transport) {
   std::string addr_str = addr->To<std::string>();
   BluetoothDevice* device = bluetooth_adapter_->GetDevice(addr_str);
   if (!device || !device->IsPairable()) {
@@ skipping 845 matching lines @@
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::BDADDR) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_bdaddr(
         mojom::BluetoothAddress::From(bluetooth_adapter_->GetAddress()));
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::UUIDS) {
-    // TODO(smbarber): Fill in once GetUUIDs is available for the adapter.
+    mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
+    btp->set_uuids(
+        mojo::Array<BluetoothUUID>::From(bluetooth_adapter_->GetUUIDs()));
+    properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::CLASS_OF_DEVICE) {
-    // TODO(smbarber): Populate with the actual adapter class
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
-    btp->set_device_class(0);
+    btp->set_device_class(kBluetoothComputerClass);
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::TYPE_OF_DEVICE) {
-    // TODO(smbarber): Populate with the actual adapter type
+    // Assume that all ChromeOS devices are dual mode Bluetooth device.
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_device_type(device::BLUETOOTH_TRANSPORT_DUAL);
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::ADAPTER_SCAN_MODE) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     mojom::BluetoothScanMode scan_mode = mojom::BluetoothScanMode::CONNECTABLE;
 
     if (bluetooth_adapter_->IsDiscoverable())
@@ skipping 221 matching lines @@
   sdp_bluetooth_instance->OnGetSdpRecords(
       status, std::move(remote_addr), target_uuid,
       mojo::Array<mojom::BluetoothSdpRecordPtr>::New(0));
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc