arc: bluetooth: Add Gatt server mojo API

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 <fcntl.h>
 #include <stddef.h>
 
 #include <iomanip>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/bluetooth/bluetooth_type_converters.h"
-#include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
-#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
-#include "device/bluetooth/bluetooth_remote_gatt_descriptor.h"
-#include "device/bluetooth/bluetooth_remote_gatt_service.h"
+#include "device/bluetooth/bluetooth_local_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_local_gatt_descriptor.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothAdvertisement;
 using device::BluetoothDevice;
 using device::BluetoothDiscoveryFilter;
 using device::BluetoothDiscoverySession;
 using device::BluetoothGattConnection;
 using device::BluetoothGattNotifySession;
 using device::BluetoothGattCharacteristic;
 using device::BluetoothGattDescriptor;
 using device::BluetoothGattService;
+using device::BluetoothLocalGattCharacteristic;
+using device::BluetoothLocalGattDescriptor;
+using device::BluetoothLocalGattService;
 using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothRemoteGattDescriptor;
 using device::BluetoothRemoteGattService;
+using device::BluetoothTransport;
 using device::BluetoothUUID;
 
 namespace {
 constexpr int32_t kMinBtleVersion = 1;
 constexpr int32_t kMinBtleNotifyVersion = 2;
 constexpr uint32_t kGattReadPermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
@@ skipping 226 matching lines @@
       true /* is_notify */, mojo::Array<uint8_t>::From(value));
 }
 
 void ArcBluetoothBridge::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   // Placeholder for GATT client functionality
 }
 
+void ArcBluetoothBridge::OnCharacteristicReadRequest(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic,
+    int offset,
+    const ValueCallback& callback,
+    const ErrorCallback& error_callback) {}

[palmer, 2016/07/16 00:21:04]

Are these functions going to be filled in with implementations in a later CL?
The actual implementations may be security-critical, and hence would need
security review. But if the only thing triggering security review is the .mojom
OWNERS file rules, we won't automatically see that code.

And I'm concerned by that |offset| argument. It's (probably) the wrong type, and
it's important to range-check and overflow-check integer math (which is
something people often forget).

[puthik_chromium, 2016/07/16 00:27:18]

The implementation is in http://crrev.com/2104043002 and
http://crrev.com/2101283003

I separate the CLs to make it not too big.

[puthik_chromium, 2016/07/18 21:27:39]

The |offset| is |int| type in Android API. 
https://source.android.com/devices/halref/bt__gatt__server_8h_source.html   line
89

+
+void ArcBluetoothBridge::OnCharacteristicWriteRequest(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic,
+    const std::vector<uint8_t>& value,
+    int offset,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {}
+
+void ArcBluetoothBridge::OnDescriptorReadRequest(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattDescriptor* descriptor,
+    int offset,
+    const ValueCallback& callback,
+    const ErrorCallback& error_callback) {}
+
+void ArcBluetoothBridge::OnDescriptorWriteRequest(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattDescriptor* descriptor,
+    const std::vector<uint8_t>& value,
+    int offset,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {}
+
+void ArcBluetoothBridge::OnNotificationsStart(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic) {}
+
+void ArcBluetoothBridge::OnNotificationsStop(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic) {}
+
 void ArcBluetoothBridge::EnableAdapter(const EnableAdapterCallback& callback) {
   DCHECK(bluetooth_adapter_);
   if (!bluetooth_adapter_->IsPowered()) {
     bluetooth_adapter_->SetPowered(
         true, base::Bind(&ArcBluetoothBridge::OnPoweredOn,
                          weak_factory_.GetWeakPtr(), callback),
         base::Bind(&ArcBluetoothBridge::OnPoweredError,
                    weak_factory_.GetWeakPtr(), callback));
     return;
   }
@@ skipping 714 matching lines @@
 
 void ArcBluetoothBridge::ReadRemoteRssi(
     mojom::BluetoothAddressPtr remote_addr,
     const ReadRemoteRssiCallback& callback) {
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   int rssi = device->GetInquiryRSSI();
   callback.Run(rssi);
 }
 
+void ArcBluetoothBridge::AddService(mojom::BluetoothGattServiceIDPtr service_id,
+                                    int32_t num_handles,
+                                    const AddServiceCallback& callback) {}
+
+void ArcBluetoothBridge::AddCharacteristic(
+    int32_t service_handle,
+    mojom::BluetoothUUIDPtr uuid,
+    int32_t properties,
+    int32_t permissions,
+    const AddCharacteristicCallback& callback) {}
+
+void ArcBluetoothBridge::AddDescriptor(int32_t service_handle,
+                                       mojom::BluetoothUUIDPtr uuid,
+                                       int32_t permissions,
+                                       const AddDescriptorCallback& callback) {}
+
+void ArcBluetoothBridge::StartService(int32_t service_handle,
+                                      const StartServiceCallback& callback) {}
+
+void ArcBluetoothBridge::StopService(int32_t service_handle,
+                                     const StopServiceCallback& callback) {}
+
+void ArcBluetoothBridge::DeleteService(int32_t service_handle,
+                                       const DeleteServiceCallback& callback) {}
+
+void ArcBluetoothBridge::SendIndication(
+    int32_t attribute_handle,
+    mojom::BluetoothAddressPtr address,
+    bool confirm,
+    mojo::Array<uint8_t> value,
+    const SendIndicationCallback& callback) {}
+
+void ArcBluetoothBridge::SendResponse(int32_t trans_id,
+                                      int32_t status,
+                                      mojo::Array<uint8_t> value,
+                                      const SendResponseCallback& callback) {}
+
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
 }
 
 void ArcBluetoothBridge::OnPairing(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     return;
 
   arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
       mojom::BluetoothStatus::SUCCESS, std::move(addr),
@@ skipping 318 matching lines @@
     uint32_t version_need) const {
   uint32_t version = arc_bridge_service()->bluetooth()->version();
   if (version >= version_need)
     return true;
   LOG(WARNING) << "Bluetooth instance is too old (version " << version
                << ") need version " << version_need;
   return false;
 }
 
 }  // namespace arc