mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

feat: add support for Web Bluetooth pin pairing (#35416)

Browse source 
* feat: add bluetooth pairing handler

* Update docs/api/session.md

Co-authored-by: Charles Kerr <charles@charleskerr.com>

* Update docs/api/session.md

Co-authored-by: Charles Kerr <charles@charleskerr.com>

* docs: update based on review

* Apply suggestions from code review

Co-authored-by: Erick Zhao <erick@hotmail.ca>
Co-authored-by: Charles Kerr <charles@charleskerr.com>

* chore: update docs per review

* chore: cleanup callback per review

Co-authored-by: Charles Kerr <charles@charleskerr.com>
Co-authored-by: Erick Zhao <erick@hotmail.ca>
This commit is contained in:
John Kleinschmidt 2022-09-26 10:19:58 -04:00 • committed by GitHub
parent f8077cc004
commit 697a219bcb
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
11 changed files with 234 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

14
shell/browser/api/electron_api_session.cc
View file

@ -674,6 +674,18 @@ void Session::SetDevicePermissionHandler(v8::Local<v8::Value> val,
permission_manager->SetDevicePermissionHandler(handler);
}
void Session::SetBluetoothPairingHandler(v8::Local<v8::Value> val,
gin::Arguments* args) {
ElectronPermissionManager::BluetoothPairingHandler handler;
if (!(val->IsNull() || gin::ConvertFromV8(args->isolate(), val, &handler))) {
args->ThrowTypeError("Must pass null or function");
return;
}
auto* permission_manager = static_cast<ElectronPermissionManager*>(
browser_context()->GetPermissionControllerDelegate());
permission_manager->SetBluetoothPairingHandler(handler);
}
v8::Local<v8::Promise> Session::ClearHostResolverCache(gin::Arguments* args) {
v8::Isolate* isolate = args->isolate();
gin_helper::Promise<void> promise(isolate);
@ -1225,6 +1237,8 @@ gin::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
&Session::SetDisplayMediaRequestHandler)
.SetMethod("setDevicePermissionHandler",
&Session::SetDevicePermissionHandler)
.SetMethod("setBluetoothPairingHandler",
&Session::SetBluetoothPairingHandler)
.SetMethod("clearHostResolverCache", &Session::ClearHostResolverCache)
.SetMethod("clearAuthCache", &Session::ClearAuthCache)
.SetMethod("allowNTLMCredentialsForDomains",

2
shell/browser/api/electron_api_session.h
View file

@ -105,6 +105,8 @@ class Session : public gin::Wrappable<Session>,
gin::Arguments* args);
void SetDevicePermissionHandler(v8::Local<v8::Value> val,
gin::Arguments* args);
void SetBluetoothPairingHandler(v8::Local<v8::Value> val,
gin::Arguments* args);
v8::Local<v8::Promise> ClearHostResolverCache(gin::Arguments* args);
v8::Local<v8::Promise> ClearAuthCache();
void AllowNTLMCredentialsForDomains(const std::string& domains);

69
shell/browser/bluetooth/electron_bluetooth_delegate.cc
View file

@ -7,6 +7,7 @@
#include <memory>
#include <utility>
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "content/public/browser/render_frame_host.h"
@ -14,7 +15,10 @@
#include "device/bluetooth/bluetooth_device.h"
#include "device/bluetooth/public/cpp/bluetooth_uuid.h"
#include "shell/browser/api/electron_api_web_contents.h"
#include "shell/browser/electron_permission_manager.h"
#include "shell/browser/lib/bluetooth_chooser.h"
#include "shell/common/gin_converters/frame_converter.h"
#include "shell/common/gin_helper/dictionary.h"
#include "third_party/blink/public/common/bluetooth/web_bluetooth_device_id.h"
#include "third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom.h"
@ -23,6 +27,28 @@ using content::RenderFrameHost;
using content::WebContents;
using device::BluetoothUUID;
namespace gin {
template <>
struct Converter<content::BluetoothDelegate::PairingKind> {
static v8::Local<v8::Value> ToV8(
v8::Isolate* isolate,
content::BluetoothDelegate::PairingKind pairing_kind) {
switch (pairing_kind) {
case content::BluetoothDelegate::PairingKind::kConfirmOnly:
return StringToV8(isolate, "confirm");
case content::BluetoothDelegate::PairingKind::kConfirmPinMatch:
return StringToV8(isolate, "confirmPin");
case content::BluetoothDelegate::PairingKind::kProvidePin:
return StringToV8(isolate, "providePin");
default:
return StringToV8(isolate, "unknown");
}
}
};
} // namespace gin
namespace electron {
ElectronBluetoothDelegate::ElectronBluetoothDelegate() = default;
@ -136,9 +162,46 @@ void ElectronBluetoothDelegate::ShowDevicePairPrompt(
PairPromptCallback callback,
PairingKind pairing_kind,
const absl::optional<std::u16string>& pin) {
NOTIMPLEMENTED();
std::move(callback).Run(BluetoothDelegate::PairPromptResult(
BluetoothDelegate::PairPromptStatus::kCancelled));
auto* web_contents = content::WebContents::FromRenderFrameHost(frame);
if (web_contents) {
auto* permission_manager = static_cast<ElectronPermissionManager*>(
web_contents->GetBrowserContext()->GetPermissionControllerDelegate());
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
v8::HandleScope scope(isolate);
gin_helper::Dictionary details =
gin_helper::Dictionary::CreateEmpty(isolate);
details.Set("deviceId", device_identifier);
details.Set("pairingKind", pairing_kind);
details.SetGetter("frame", frame);
if (pin.has_value()) {
details.Set("pin", pin.value());
}
permission_manager->CheckBluetoothDevicePair(
details, base::AdaptCallbackForRepeating(base::BindOnce(
&ElectronBluetoothDelegate::OnDevicePairPromptResponse,
weak_factory_.GetWeakPtr(), std::move(callback))));
}
}
void ElectronBluetoothDelegate::OnDevicePairPromptResponse(
PairPromptCallback callback,
base::Value::Dict response) {
BluetoothDelegate::PairPromptResult result;
if (response.FindBool("confirmed").value_or(false)) {
result.result_code = BluetoothDelegate::PairPromptStatus::kSuccess;
} else {
result.result_code = BluetoothDelegate::PairPromptStatus::kCancelled;
}
const std::string* pin = response.FindString("pin");
if (pin) {
std::u16string trimmed_input = base::UTF8ToUTF16(*pin);
base::TrimWhitespace(trimmed_input, base::TRIM_ALL, &trimmed_input);
result.pin = base::UTF16ToUTF8(trimmed_input);
}
std::move(callback).Run(result);
}
} // namespace electron

7
shell/browser/bluetooth/electron_bluetooth_delegate.h
View file

@ -9,6 +9,7 @@
#include <string>
#include <vector>
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/scoped_observation.h"
#include "content/public/browser/bluetooth_delegate.h"
@ -91,6 +92,12 @@ class ElectronBluetoothDelegate : public content::BluetoothDelegate {
void AddFramePermissionObserver(FramePermissionObserver* observer) override;
void RemoveFramePermissionObserver(
FramePermissionObserver* observer) override;
private:
void OnDevicePairPromptResponse(PairPromptCallback callback,
base::Value::Dict response);
base::WeakPtrFactory<ElectronBluetoothDelegate> weak_factory_{this};
};
} // namespace electron

17
shell/browser/electron_permission_manager.cc
View file

@ -130,6 +130,11 @@ void ElectronPermissionManager::SetDevicePermissionHandler(
device_permission_handler_ = handler;
}
void ElectronPermissionManager::SetBluetoothPairingHandler(
const BluetoothPairingHandler& handler) {
bluetooth_pairing_handler_ = handler;
}
void ElectronPermissionManager::RequestPermission(
blink::PermissionType permission,
content::RenderFrameHost* render_frame_host,
@ -276,6 +281,18 @@ ElectronPermissionManager::SubscribePermissionStatusChange(
void ElectronPermissionManager::UnsubscribePermissionStatusChange(
SubscriptionId id) {}
void ElectronPermissionManager::CheckBluetoothDevicePair(
gin_helper::Dictionary details,
PairCallback pair_callback) const {
if (bluetooth_pairing_handler_.is_null()) {
base::Value::Dict response;
response.Set("confirmed", false);
std::move(pair_callback).Run(std::move(response));
} else {
bluetooth_pairing_handler_.Run(details, std::move(pair_callback));
}
}
bool ElectronPermissionManager::CheckPermissionWithDetails(
blink::PermissionType permission,
content::RenderFrameHost* render_frame_host,

9
shell/browser/electron_permission_manager.h
View file

@ -13,6 +13,7 @@
#include "content/public/browser/permission_controller_delegate.h"
#include "gin/dictionary.h"
#include "shell/browser/electron_browser_context.h"
#include "shell/common/gin_helper/dictionary.h"
namespace base {
class Value;
@ -38,6 +39,7 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
base::OnceCallback<void(blink::mojom::PermissionStatus)>;
using StatusesCallback = base::OnceCallback<void(
const std::vector<blink::mojom::PermissionStatus>&)>;
using PairCallback = base::OnceCallback<void(base::Value::Dict)>;
using RequestHandler = base::RepeatingCallback<void(content::WebContents*,
blink::PermissionType,
StatusCallback,
@ -50,11 +52,14 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
using DeviceCheckHandler =
base::RepeatingCallback<bool(const v8::Local<v8::Object>&)>;
using BluetoothPairingHandler =
base::RepeatingCallback<void(gin_helper::Dictionary, PairCallback)>;
// Handler to dispatch permission requests in JS.
void SetPermissionRequestHandler(const RequestHandler& handler);
void SetPermissionCheckHandler(const CheckHandler& handler);
void SetDevicePermissionHandler(const DeviceCheckHandler& handler);
void SetBluetoothPairingHandler(const BluetoothPairingHandler& handler);
// content::PermissionControllerDelegate:
void RequestPermission(blink::PermissionType permission,
@ -81,6 +86,9 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
base::Value::Dict details,
StatusesCallback callback);
void CheckBluetoothDevicePair(gin_helper::Dictionary details,
PairCallback pair_callback) const;
bool CheckPermissionWithDetails(blink::PermissionType permission,
content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin,
@ -147,6 +155,7 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
RequestHandler request_handler_;
CheckHandler check_handler_;
DeviceCheckHandler device_permission_handler_;
BluetoothPairingHandler bluetooth_pairing_handler_;
PendingRequestsMap pending_requests_;
};