Implement create attribute API functions for BTLE.

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.cc

 // 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 "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <iterator>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_forward.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/utils.h"
 #include "chrome/common/extensions/api/bluetooth_low_energy.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_local_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_local_gatt_descriptor.h"
+#include "device/bluetooth/bluetooth_local_gatt_service.h"
+#include "device/bluetooth/bluetooth_uuid.h"
 #include "extensions/common/api/bluetooth/bluetooth_manifest_data.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/switches.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
@@ skipping 22 matching lines @@
 const char kErrorNotNotifying[] = "Not notifying";
 const char kErrorOffsetInvalid[] = "Offset invalid";
 const char kErrorOperationFailed[] = "Operation failed";
 const char kErrorPermissionDenied[] = "Permission denied";
 const char kErrorPlatformNotSupported[] =
     "This operation is not supported on the current platform";
 const char kErrorRequestNotSupported[] = "Request not supported";
 const char kErrorTimeout[] = "Operation timed out";
 const char kErrorUnsupportedDevice[] =
     "This device is not supported on the current platform";
+const char kErrorInvalidServiceId[] = "The service ID doesn't exist.";
+const char kErrorInvalidCharacteristicId[] =
+    "The characteristic ID doesn't exist.";
 const char kStatusAdvertisementAlreadyExists[] =
     "An advertisement is already advertising";
 const char kStatusAdvertisementDoesNotExist[] =
     "This advertisement does not exist";
 
 // Returns the correct error string based on error status |status|. This is used
 // to set the value of |chrome.runtime.lastError.message| and should not be
 // passed |BluetoothLowEnergyEventRouter::kStatusSuccess|.
 std::string StatusToString(BluetoothLowEnergyEventRouter::Status status) {
   switch (status) {
@@ skipping 141 matching lines @@
           &DoWorkCallback<bool>,
           base::Bind(&BluetoothLowEnergyExtensionFunctionDeprecated::DoWork,
                      this)))) {
     SetError(kErrorAdapterNotInitialized);
     return false;
   }
 
   return true;
 }
 
-BluetoothLowEnergyExtensionFunction::BluetoothLowEnergyExtensionFunction() {}
+BluetoothLowEnergyExtensionFunction::BluetoothLowEnergyExtensionFunction()
+    : event_router_(nullptr) {}
 
 BluetoothLowEnergyExtensionFunction::~BluetoothLowEnergyExtensionFunction() {}
 
 ExtensionFunction::ResponseAction BluetoothLowEnergyExtensionFunction::Run() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!BluetoothManifestData::CheckLowEnergyPermitted(extension()))
     return RespondNow(Error(kErrorPermissionDenied));
 
-  BluetoothLowEnergyEventRouter* event_router =
-      GetEventRouter(browser_context());
-  if (!event_router->IsBluetoothSupported())
+  event_router_ = GetEventRouter(browser_context());
+  if (!event_router_->IsBluetoothSupported())
     return RespondNow(Error(kErrorPlatformNotSupported));
 
   // It is safe to pass |this| here as ExtensionFunction is refcounted.
-  if (!event_router->InitializeAdapterAndInvokeCallback(base::Bind(
+  if (!event_router_->InitializeAdapterAndInvokeCallback(base::Bind(
           &DoWorkCallback<void>,
-          base::Bind(&BluetoothLowEnergyExtensionFunction::DoWork, this)))) {
+          base::Bind(&BluetoothLowEnergyExtensionFunction::PreDoWork, this)))) {
     // DoWork will respond when the adapter gets initialized.
     return RespondNow(Error(kErrorAdapterNotInitialized));
   }
 
   return RespondLater();
 }
 
+void BluetoothLowEnergyExtensionFunction::PreDoWork() {
+  // The adapter must be initialized at this point, but return an error instead
+  // of asserting.
+  if (!event_router_->HasAdapter()) {
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
+  }
+  DoWork();
+}
+
 template <typename Params>
 BLEPeripheralExtensionFunction<Params>::BLEPeripheralExtensionFunction() {}
 
 template <typename Params>
 BLEPeripheralExtensionFunction<Params>::~BLEPeripheralExtensionFunction() {}
 
 template <typename Params>
 ExtensionFunction::ResponseAction
 BLEPeripheralExtensionFunction<Params>::Run() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   // Check permissions in manifest.
   if (!BluetoothManifestData::CheckPeripheralPermitted(extension()))
     return RespondNow(Error(kErrorPermissionDenied));
 
   params_ = Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get() != NULL);
 
   return BluetoothLowEnergyExtensionFunction::Run();
 }
 
@@ skipping 843 matching lines @@
 
 template class BLEPeripheralExtensionFunction<apibtle::CreateService::Params>;
 
 void BluetoothLowEnergyCreateServiceFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 // Using apibtle::CreateService::Results::Create causes a link error on
 // Windows for some reason, despite it being almost identical to its
 // characteristic and descriptor counterparts. Since there is no plan to
 // provide this API on Windows, ifdef'ing this out is fine.
 #if !defined(OS_WIN)
-  Respond(ArgumentList(apibtle::CreateService::Results::Create(std::string())));
+  base::WeakPtr<device::BluetoothLocalGattService> service =
+      device::BluetoothLocalGattService::Create(
+          event_router_->adapter(),
+          device::BluetoothUUID(params_->service.uuid),
+          params_->service.is_primary, nullptr, nullptr);
+
+  Respond(ArgumentList(
+      apibtle::CreateService::Results::Create(service->GetIdentifier())));
 #else
   Respond(Error(kErrorPlatformNotSupported));
 #endif
 }
 
 template class BLEPeripheralExtensionFunction<
     apibtle::CreateCharacteristic::Params>;
 
 void BluetoothLowEnergyCreateCharacteristicFunction::DoWork() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  Respond(ArgumentList(
-      apibtle::CreateCharacteristic::Results::Create(std::string())));
+  device::BluetoothLocalGattService* service =
+      event_router_->adapter()->GetGattService(params_->service_id);
+  if (!service) {
+    Respond(Error(kErrorInvalidServiceId));
+    return;
+  }
+
+  base::WeakPtr<device::BluetoothLocalGattCharacteristic> characteristic =
+      device::BluetoothLocalGattCharacteristic::Create(
+          device::BluetoothUUID(params_->characteristic.uuid),
+          device::BluetoothGattCharacteristic::Properties(),
+          device::BluetoothGattCharacteristic::Permissions(), service);
+
+  // Keep a track of this characteristic so we can look it up later if a
+  // descriptor lists it as its parent.
+  event_router_->AddLocalCharacteristic(characteristic->GetIdentifier(),
+                                        service->GetIdentifier());
+
+  Respond(ArgumentList(apibtle::CreateCharacteristic::Results::Create(
+      characteristic->GetIdentifier())));
 }
 
 template class BLEPeripheralExtensionFunction<
     apibtle::CreateDescriptor::Params>;
 
 void BluetoothLowEnergyCreateDescriptorFunction::DoWork() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  Respond(
-      ArgumentList(apibtle::CreateDescriptor::Results::Create(std::string())));
+  device::BluetoothLocalGattCharacteristic* characteristic =
+      event_router_->GetLocalCharacteristic(params_->characteristic_id);
+  if (!characteristic) {
+    Respond(Error(kErrorInvalidCharacteristicId));
+    return;
+  }
+
+  base::WeakPtr<device::BluetoothLocalGattDescriptor> descriptor =
+      device::BluetoothLocalGattDescriptor::Create(
+          device::BluetoothUUID(params_->descriptor.uuid),
+          device::BluetoothGattCharacteristic::Permissions(), characteristic);
+
+  Respond(ArgumentList(
+      apibtle::CreateDescriptor::Results::Create(descriptor->GetIdentifier())));
 }
 
 template class BLEPeripheralExtensionFunction<apibtle::RegisterService::Params>;
 
 void BluetoothLowEnergyRegisterServiceFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Respond(ArgumentList(apibtle::RegisterService::Results::Create(
       apibtle::SERVICE_RESULT_SUCCESS)));
 }
 
 template class BLEPeripheralExtensionFunction<
     apibtle::UnregisterService::Params>;
 
 void BluetoothLowEnergyUnregisterServiceFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Respond(ArgumentList(apibtle::UnregisterService::Results::Create(
       apibtle::SERVICE_RESULT_SUCCESS)));
 }
 
 template class BLEPeripheralExtensionFunction<
     apibtle::SendRequestResponse::Params>;
 
 void BluetoothLowEnergySendRequestResponseFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Respond(NoArguments());
 }
 
 }  // namespace api
 }  // namespace extensions