### Preflight Checklist

- [X] I have read the [Contributing Guidelines](https://github.com/electron/electron/blob/main/CONTRIBUTING.md) for this project.
- [X] I agree to follow the [Code of Conduct](https://github.com/electron/electron/blob/main/CODE_OF_CONDUCT.md) that this project adheres to.
- [X] I have searched the [issue tracker](https://www.github.com/electron/electron/issues) for a feature request that matches the one I want to file, without success.

### Electron Version

15.3.0

### What operating system are you using?

macOS

### Operating System Version

11.6

### What arch are you using?

arm64 (including Apple Silicon)

### Last Known Working Electron version

_No response_

### Expected Behavior

The default HID block list prohibits access to FIDO devices for web applications, but can be disabled via `disable-hid-blocklist` switch (internally `kDisableHidBlocklist`). 

```
app.commandLine.appendSwitch('disable-hid-blocklist');
```

After disabling the blocklist, I can enumerate and open a FIDO device, and should be able to call the device's `sendFeatureReport`, `sendReport`, and `receiveFeatureReport` methods to communicate with it.



### Actual Behavior

Calls to the `HIDDevice`'s `sendFeatureReport`, `sendReport` and `receiveFeatureReport` methods all result in a [`NotAllowedError`](https://webidl.spec.whatwg.org/#notallowederror).

### Testcase Gist URL

_No response_

### Additional Information

I believe the cause of this behavior is that the HID implementation does not account for the disabling of the blocklist in its implementation of IsFidoAllowedForOrigin, returning a hard-coded `false` even if the blocklist has been disabled.

https://github.com/electron/electron/blob/deb7ab2a40910f14bdb418fdf060c5daf1a0905c/shell/browser/hid/electron_hid_delegate.cc#L106

I'd propose to instead return true if the the application has chosen to disable the blocklist.
```cpp
  return base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableHidBlocklist);
```

One could optionally add another configuration switch for origins other than those starting with `"file://"` if you are worried an implementer might allow access to FIDO devices unintentionally (though seems unlikely given how few disable the HID block list, and that they typically will filter for the devices they are looking for anyway).

There are legitimate reasons for apps to want to communicate with devices that expose a FIDO HID interface our app is not doing anything that violates the security of the FIDO devices it interacts with or violates users' security expectations.  Rather, there are FIDO devices (e.g., those from SoloKeys) designed expressly to interact with our app via the HID interface.

Preventing application authors from accessing FIDO devices through this interface is antithetical to security because it is still possible for apps to do so (via the usb-detection and node-hid packages) but those mechanisms increase the application's attack surface.  We wanted to move away from those packages because each dependency is a potential source of a supply chain attack, and each can make it harder to update the project when new version of Electron with security updates come out, as we have to wait for the dependencies to be compatible with the latest version of electron.

I'm very excited to see that @jkleinsc and @nornagon have gotten WebHID support to the point where we can _almost_ use it and increase the security of our application.  I'm really hoping they can take this last step to fix this issue!  Thanks!

shell/browser/hid/electron_hid_delegate.cc
device_observation_.Reset();
}
HidChooserController* ElectronHidDelegate::ControllerForFrame(
    content::RenderFrameHost* render_frame_host) {
  auto mapping = controller_map_.find(render_frame_host);
  return mapping == controller_map_.end() ? nullptr : mapping->second.get();
}
HidChooserController* ElectronHidDelegate::AddControllerForFrame(
    content::RenderFrameHost* render_frame_host,
    std::vector<blink::mojom::HidDeviceFilterPtr> filters,
    content::HidChooser::Callback callback) {
  auto* web_contents =
      content::WebContents::FromRenderFrameHost(render_frame_host);
  auto controller = std::make_unique<HidChooserController>(
      render_frame_host, std::move(filters), std::move(callback), web_contents,
      weak_factory_.GetWeakPtr());
  controller_map_.insert(
      std::make_pair(render_frame_host, std::move(controller)));
  return ControllerForFrame(render_frame_host);
}
void ElectronHidDelegate::DeleteControllerForFrame(
    content::RenderFrameHost* render_frame_host) {
  controller_map_.erase(render_frame_host);
}
}