API Bindings for GATT server functionality.

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 <utility>
+#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/strings/stringprintf.h"
-#include "build/build_config.h"
-#include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_api_advertisement.h"
+#include "base/logging.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 "extensions/browser/event_router.h"
+#include "device/bluetooth/bluetooth_adapter.h"
 #include "extensions/common/api/bluetooth/bluetooth_manifest_data.h"
-#include "extensions/common/permissions/permissions_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;
 
-namespace apibtle = extensions::api::bluetooth_low_energy;
-
 namespace extensions {
 
 namespace {
 
 const char kErrorAdapterNotInitialized[] =
     "Could not initialize Bluetooth adapter";
 const char kErrorAlreadyConnected[] = "Already connected";
 const char kErrorAlreadyNotifying[] = "Already notifying";
 const char kErrorAttributeLengthInvalid[] = "Attribute length invalid";
 const char kErrorAuthenticationFailed[] = "Authentication failed";
@@ skipping 76 matching lines @@
   }
   return "";
 }
 
 extensions::BluetoothLowEnergyEventRouter* GetEventRouter(
     BrowserContext* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return extensions::BluetoothLowEnergyAPI::Get(context)->event_router();
 }
 
-void DoWorkCallback(const base::Callback<bool()>& callback) {
+template <typename T>
+void DoWorkCallback(const base::Callback<T()>& callback) {
   DCHECK(!callback.is_null());
   callback.Run();
 }
 
 std::unique_ptr<device::BluetoothAdvertisement::ManufacturerData>
 CreateManufacturerData(
     std::vector<apibtle::ManufacturerData>* manufacturer_data) {
   std::unique_ptr<device::BluetoothAdvertisement::ManufacturerData>
       created_data(new device::BluetoothAdvertisement::ManufacturerData());
   for (const auto& it : *manufacturer_data) {
@@ skipping 41 matching lines @@
 
 BluetoothLowEnergyAPI::~BluetoothLowEnergyAPI() {
 }
 
 void BluetoothLowEnergyAPI::Shutdown() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 namespace api {
 
-BluetoothLowEnergyExtensionFunction::BluetoothLowEnergyExtensionFunction() {
-}
+BluetoothLowEnergyExtensionFunctionDeprecated::
+    BluetoothLowEnergyExtensionFunctionDeprecated() {}
 
-BluetoothLowEnergyExtensionFunction::~BluetoothLowEnergyExtensionFunction() {
-}
+BluetoothLowEnergyExtensionFunctionDeprecated::
+    ~BluetoothLowEnergyExtensionFunctionDeprecated() {}
 
-bool BluetoothLowEnergyExtensionFunction::RunAsync() {
+bool BluetoothLowEnergyExtensionFunctionDeprecated::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!BluetoothManifestData::CheckLowEnergyPermitted(extension())) {
     error_ = kErrorPermissionDenied;
     return false;
   }
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
   if (!event_router->IsBluetoothSupported()) {
     SetError(kErrorPlatformNotSupported);
     return false;
   }
 
   // It is safe to pass |this| here as ExtensionFunction is refcounted.
   if (!event_router->InitializeAdapterAndInvokeCallback(base::Bind(
-          &DoWorkCallback,
-          base::Bind(&BluetoothLowEnergyExtensionFunction::DoWork, this)))) {
+          &DoWorkCallback<bool>,
+          base::Bind(&BluetoothLowEnergyExtensionFunctionDeprecated::DoWork,
+                     this)))) {
     SetError(kErrorAdapterNotInitialized);
     return false;
   }
 
   return true;
 }
 
+BluetoothLowEnergyExtensionFunction::BluetoothLowEnergyExtensionFunction() {}
+
+BluetoothLowEnergyExtensionFunction::~BluetoothLowEnergyExtensionFunction() {}
+
+ExtensionFunction::ResponseAction BluetoothLowEnergyExtensionFunction::Run() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (!BluetoothManifestData::CheckLowEnergyPermitted(extension()))

[Devlin, 2016/05/02 17:04:39]

This still isn't ideal, because:
a) The bluetooth api object is available to the extension, i.e.
chrome.bluetoothLowEnergy.createService() will exist.
b) This code will need to be compiled cross-platform.
c) Everyone writing a new function here needs to remember to do this.
d) It makes it a lot harder to find out where these functions are actually
supported.

I'd much rather we support this through our features files - we have them to
address exactly these cases.  It looks like CheckLowEnergyPermitted() basically
just checks a bit of the manifest - is there a reason we can't have that bit
restricted to a certain platform in the _manifest_features.json file, and depend
upon it in the api_features_.json file?

+    return RespondNow(Error(kErrorPermissionDenied));
+
+  BluetoothLowEnergyEventRouter* 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(
+          &DoWorkCallback<void>,
+          base::Bind(&BluetoothLowEnergyExtensionFunction::DoWork, this)))) {
+    // DoWork will respond when the adapter gets initialized.
+    return RespondNow(Error(kErrorAdapterNotInitialized));
+  }
+
+  return RespondLater();
+}
+
+template <typename Params>
+BLEPeripheralExtensionFunction<Params>::BLEPeripheralExtensionFunction() {}
+
+template <typename Params>
+BLEPeripheralExtensionFunction<Params>::~BLEPeripheralExtensionFunction() {}
+
+template <typename Params>
+ExtensionFunction::ResponseAction
+BLEPeripheralExtensionFunction<Params>::Run() {
+  // 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();
+}
+
 bool BluetoothLowEnergyConnectFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
@@ skipping 633 matching lines @@
 }
 
 void BluetoothLowEnergyAdvertisementFunction::RemoveAdvertisement(
     int advertisement_id) {
   DCHECK(advertisements_manager_);
   advertisements_manager_->Remove(extension_id(), advertisement_id);
 }
 
 bool BluetoothLowEnergyAdvertisementFunction::RunAsync() {
   Initialize();
-  return BluetoothLowEnergyExtensionFunction::RunAsync();
+  return BluetoothLowEnergyExtensionFunctionDeprecated::RunAsync();
 }
 
 void BluetoothLowEnergyAdvertisementFunction::Initialize() {
   advertisements_manager_ =
       ApiResourceManager<BluetoothApiAdvertisement>::Get(browser_context());
 }
 
 static bool IsAutoLaunchedKioskApp(const ExtensionId& id) {
 #if defined(OS_CHROMEOS)
   chromeos::KioskAppManager::App app_info;
@@ skipping 170 matching lines @@
     case device::BluetoothAdvertisement::ErrorCode::
         ERROR_ADVERTISEMENT_DOES_NOT_EXIST:
       SetError(kStatusAdvertisementDoesNotExist);
       break;
     default:
       SetError(kErrorOperationFailed);
   }
   SendResponse(false);
 }
 
+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())));
+#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())));
+}
+
+template class BLEPeripheralExtensionFunction<
+    apibtle::CreateDescriptor::Params>;
+
+void BluetoothLowEnergyCreateDescriptorFunction::DoWork() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  Respond(
+      ArgumentList(apibtle::CreateDescriptor::Results::Create(std::string())));
+}
+
+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