Implement struct based embedder/device interface

Currently, ChromeAuthenticatorRequestDelegate implements
FidoRequestHandlerBase::AuthenticatorMap interface, and each events in
transport layer trigger observer function in the embedder.

In order to make embedder interface simpler, aggregate all transport
layer events that is required prior to initiating WebAuthN UI dialog
in FidoRequestHandlerBase. Once all the information is gathered, combine
all retrieved data in FidoUiAprioriData struct and invoke single
OnTransportLayerInfoReceived() observer function in the embedder layer.

Bug: 866601
Change-Id: Id9ac2456fca14351682a8c72a7813c3f8674c552
Reviewed-on: https://chromium-review.googlesource.com/1170041
Commit-Queue: Jun Choi <hongjunchoi@chromium.org>
Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#582756}

chrome/browser/webauthn/chrome_authenticator_request_delegate.cc

@@ -256,34 +256,14 @@ ChromeAuthenticatorRequestDelegate::GetLastTransportUsed() const {
       prefs->GetString(kWebAuthnLastTransportUsedPrefName));
 }
 
-void ChromeAuthenticatorRequestDelegate::BluetoothAdapterIsAvailable() {
-  if (!IsWebAuthnUiEnabled())
-    return;
-
-  DCHECK(weak_dialog_model_);
-  weak_dialog_model_->transport_list_model()->AppendTransport(
-      AuthenticatorTransport::kBluetoothLowEnergy);
-}
-
 void ChromeAuthenticatorRequestDelegate::FidoAuthenticatorAdded(
     const device::FidoAuthenticator& authenticator) {
   if (!IsWebAuthnUiEnabled())
     return;
 
   DCHECK(weak_dialog_model_);
-
-  // We are only caching device information for BLE and platform authenticators.
-  const auto transport = authenticator.AuthenticatorTransport();
-  if (transport == device::FidoTransportProtocol::kInternal ||
-      transport == device::FidoTransportProtocol::kBluetoothLowEnergy) {
-    if (transport == device::FidoTransportProtocol::kInternal) {
-      weak_dialog_model_->transport_list_model()->AppendTransport(
-          AuthenticatorTransport::kInternal);
-    }
-
-    weak_dialog_model_->saved_authenticators().emplace_back(
-        authenticator.GetId(), authenticator.AuthenticatorTransport());
-  }
+  weak_dialog_model_->saved_authenticators().emplace_back(
+      authenticator.GetId(), authenticator.AuthenticatorTransport());
 }
 
 void ChromeAuthenticatorRequestDelegate::FidoAuthenticatorRemoved(
@@ -294,13 +274,10 @@ void ChromeAuthenticatorRequestDelegate::FidoAuthenticatorRemoved(
   DCHECK(weak_dialog_model_);
   auto& saved_authenticators = weak_dialog_model_->saved_authenticators();
   saved_authenticators.erase(
-      std::remove_if(
-          saved_authenticators.begin(), saved_authenticators.end(),
-          [device_id](const auto& authenticator_reference) {
-            return authenticator_reference.transport ==
-                       device::FidoTransportProtocol::kBluetoothLowEnergy &&
-                   authenticator_reference.device_id == device_id;
-          }),
+      std::remove_if(saved_authenticators.begin(), saved_authenticators.end(),
+                     [device_id](const auto& authenticator_reference) {
+                       return authenticator_reference.device_id == device_id;
+                     }),
       saved_authenticators.end());
 }
 

chrome/browser/webauthn/chrome_authenticator_request_delegate.h

@@ -69,12 +69,13 @@ class ChromeAuthenticatorRequestDelegate
       const std::string& relying_party_id,
       base::OnceCallback<void(bool)> callback) override;
   bool IsFocused() override;
-  void BluetoothAdapterIsAvailable() override;
+  void UpdateLastTransportUsed(
+      device::FidoTransportProtocol transport) override;
+
+  // device::FidoRequestHandlerBase::TransportAvailabilityObserver:
   void FidoAuthenticatorAdded(
       const device::FidoAuthenticator& authenticator) override;
   void FidoAuthenticatorRemoved(base::StringPiece device_id) override;
-  void UpdateLastTransportUsed(
-      device::FidoTransportProtocol transport) override;
 
   // AuthenticatorRequestDialogModel::Observer:
   void OnModelDestroyed() override;

content/browser/webauth/authenticator_impl_unittest.cc

@@ -1669,7 +1669,9 @@ class MockAuthenticatorRequestDelegateObserver
             true /* is_focused */) {}
   ~MockAuthenticatorRequestDelegateObserver() override = default;
 
-  MOCK_METHOD0(BluetoothAdapterIsAvailable, void());
+  MOCK_METHOD1(
+      OnTransportAvailabilityEnumerated,
+      void(device::FidoRequestHandlerBase::TransportAvailabilityInfo data));
   MOCK_METHOD1(FidoAuthenticatorAdded, void(const device::FidoAuthenticator&));
   MOCK_METHOD1(FidoAuthenticatorRemoved, void(base::StringPiece));
 
@@ -1780,7 +1782,7 @@ TEST_F(AuthenticatorImplRequestDelegateTest,
       device::FidoTransportProtocol::kBluetoothLowEnergy);
   const auto device_id = mock_ble_device->GetId();
 
-  EXPECT_CALL(*mock_delegate_ptr, BluetoothAdapterIsAvailable());
+  EXPECT_CALL(*mock_delegate_ptr, OnTransportAvailabilityEnumerated(_));
 
   base::RunLoop ble_device_found_done;
   EXPECT_CALL(*mock_delegate_ptr, FidoAuthenticatorAdded(_))

content/public/browser/authenticator_request_client_delegate.cc

@@ -40,7 +40,14 @@ AuthenticatorRequestClientDelegate::GetTouchIdAuthenticatorConfig() const {
 }
 #endif
 
-void AuthenticatorRequestClientDelegate::BluetoothAdapterIsAvailable() {}
+void AuthenticatorRequestClientDelegate::UpdateLastTransportUsed(
+    device::FidoTransportProtocol transport) {}
+
+void AuthenticatorRequestClientDelegate::OnTransportAvailabilityEnumerated(
+    device::FidoRequestHandlerBase::TransportAvailabilityInfo data) {}
+
+void AuthenticatorRequestClientDelegate::BluetoothAdapterPowerChanged(
+    bool is_powered_on) {}
 
 void AuthenticatorRequestClientDelegate::FidoAuthenticatorAdded(
     const device::FidoAuthenticator& authenticator) {}
@@ -48,7 +55,4 @@ void AuthenticatorRequestClientDelegate::FidoAuthenticatorAdded(
 void AuthenticatorRequestClientDelegate::FidoAuthenticatorRemoved(
     base::StringPiece device_id) {}
 
-void AuthenticatorRequestClientDelegate::UpdateLastTransportUsed(
-    device::FidoTransportProtocol transport) {}
-
 }  // namespace content

content/public/browser/authenticator_request_client_delegate.h

@@ -27,7 +27,7 @@ namespace content {
 //
 // [1]: See https://www.w3.org/TR/webauthn/.
 class CONTENT_EXPORT AuthenticatorRequestClientDelegate
-    : public device::FidoRequestHandlerBase::AuthenticatorMapObserver {
+    : public device::FidoRequestHandlerBase::TransportAvailabilityObserver {
  public:
   AuthenticatorRequestClientDelegate();
   ~AuthenticatorRequestClientDelegate() override;
@@ -87,8 +87,10 @@ class CONTENT_EXPORT AuthenticatorRequestClientDelegate
   // WebAuthN UI will default to the same transport type during next API call.
   virtual void UpdateLastTransportUsed(device::FidoTransportProtocol transport);
 
-  // device::FidoRequestHandlerBase::AuthenticatorMapObserver:
-  void BluetoothAdapterIsAvailable() override;
+  // device::FidoRequestHandlerBase::TransportAvailabilityObserver:
+  void OnTransportAvailabilityEnumerated(
+      device::FidoRequestHandlerBase::TransportAvailabilityInfo data) override;
+  void BluetoothAdapterPowerChanged(bool is_powered_on) override;
   void FidoAuthenticatorAdded(
       const device::FidoAuthenticator& authenticator) override;
   void FidoAuthenticatorRemoved(base::StringPiece device_id) override;

device/fido/fido_request_handler_base.cc

@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "base/barrier_closure.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "build/build_config.h"
@@ -17,6 +18,10 @@ namespace device {
 
 namespace {
 
+// Number of async calls we need to wait before notifying the embedder layer
+// of FidoUiAprioriData.
+constexpr size_t kNumAsyncTransportInfoCallbacks = 2;
+
 bool ShouldDeferRequestDispatchToUi(const FidoAuthenticator& authenticator) {
   // TODO(hongjunchoi): Change this to be dependent on authenticator transport
   // type once UI component is in place.
@@ -25,9 +30,28 @@ bool ShouldDeferRequestDispatchToUi(const FidoAuthenticator& authenticator) {
 
 }  // namespace
 
-FidoRequestHandlerBase::AuthenticatorMapObserver::~AuthenticatorMapObserver() =
+// FidoRequestHandlerBase::TransportAvailabilityInfo --------------------------
+
+FidoRequestHandlerBase::TransportAvailabilityInfo::TransportAvailabilityInfo() =
     default;
 
+FidoRequestHandlerBase::TransportAvailabilityInfo::TransportAvailabilityInfo(
+    const TransportAvailabilityInfo& data) = default;
+
+FidoRequestHandlerBase::TransportAvailabilityInfo&
+FidoRequestHandlerBase::TransportAvailabilityInfo::operator=(
+    const TransportAvailabilityInfo& other) = default;
+
+FidoRequestHandlerBase::TransportAvailabilityInfo::
+    ~TransportAvailabilityInfo() = default;
+
+// FidoRequestHandlerBase::TransportAvailabilityObserver ----------------------
+
+FidoRequestHandlerBase::TransportAvailabilityObserver::
+    ~TransportAvailabilityObserver() = default;
+
+// FidoRequestHandlerBase -----------------------------------------------------
+
 FidoRequestHandlerBase::FidoRequestHandlerBase(
     service_manager::Connector* connector,
     const base::flat_set<FidoTransportProtocol>& transports)
@@ -39,7 +63,8 @@ FidoRequestHandlerBase::FidoRequestHandlerBase(
     service_manager::Connector* connector,
     const base::flat_set<FidoTransportProtocol>& transports,
     AddPlatformAuthenticatorCallback add_platform_authenticator)
-    : add_platform_authenticator_(std::move(add_platform_authenticator)) {
+    : add_platform_authenticator_(std::move(add_platform_authenticator)),
+      weak_factory_(this) {
   for (const auto transport : transports) {
     // Construction of CaBleDiscovery is handled by the implementing class as it
     // requires an extension passed on from the relying party.
@@ -62,6 +87,11 @@ FidoRequestHandlerBase::FidoRequestHandlerBase(
     discovery->set_observer(this);
     discoveries_.push_back(std::move(discovery));
   }
+
+  notify_observer_callback_ = base::BarrierClosure(
+      kNumAsyncTransportInfoCallbacks,
+      base::BindOnce(&FidoRequestHandlerBase::NotifyObserverUiData,
+                     weak_factory_.GetWeakPtr()));
 }
 
 FidoRequestHandlerBase::~FidoRequestHandlerBase() = default;
@@ -88,22 +118,21 @@ void FidoRequestHandlerBase::Start() {
   MaybeAddPlatformAuthenticator();
 }
 
-void FidoRequestHandlerBase::MaybeAddPlatformAuthenticator() {
-  if (!add_platform_authenticator_)
-    return;
-
-  auto authenticator = std::move(add_platform_authenticator_).Run();
-  if (!authenticator)
-    return;
-
-  AddAuthenticator(std::move(authenticator));
-}
 
 void FidoRequestHandlerBase::DiscoveryStarted(FidoDiscovery* discovery,
                                               bool success) {
-  if (discovery->transport() == FidoTransportProtocol::kBluetoothLowEnergy &&
-      observer_) {
-    observer_->BluetoothAdapterIsAvailable();
+  if (discovery->transport() == FidoTransportProtocol::kBluetoothLowEnergy) {
+    // For FidoBleDiscovery, discovery is started with |success| set to true
+    // if device::BluetoothAdapter is present in the system.
+    if (!success) {
+      transport_availability_info_.available_transports.erase(
+          FidoTransportProtocol::kBluetoothLowEnergy);
+      transport_availability_info_.available_transports.erase(
+          FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy);
+    }
+
+    DCHECK(notify_observer_callback_);
+    notify_observer_callback_.Run();
   }
 }
 
@@ -139,7 +168,6 @@ void FidoRequestHandlerBase::AddAuthenticator(
   FidoAuthenticator* authenticator_ptr = authenticator.get();
   active_authenticators_.emplace(authenticator->GetId(),
                                  std::move(authenticator));
-
   if (!ShouldDeferRequestDispatchToUi(*authenticator_ptr))
     DispatchRequest(authenticator_ptr);
 
@@ -147,4 +175,27 @@ void FidoRequestHandlerBase::AddAuthenticator(
     observer_->FidoAuthenticatorAdded(*authenticator_ptr);
 }
 
+void FidoRequestHandlerBase::MaybeAddPlatformAuthenticator() {
+  std::unique_ptr<FidoAuthenticator> authenticator;
+  if (add_platform_authenticator_)
+    authenticator = std::move(add_platform_authenticator_).Run();
+
+  if (authenticator) {
+    AddAuthenticator(std::move(authenticator));
+  } else {
+    transport_availability_info_.available_transports.erase(
+        FidoTransportProtocol::kInternal);
+  }
+
+  DCHECK(notify_observer_callback_);
+  notify_observer_callback_.Run();
+}
+
+void FidoRequestHandlerBase::NotifyObserverUiData() {
+  if (!observer_)
+    return;
+
+  observer_->OnTransportAvailabilityEnumerated(transport_availability_info_);
+}
+
 }  // namespace device

device/fido/fido_request_handler_base.h

@@ -8,6 +8,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -43,11 +44,34 @@ class COMPONENT_EXPORT(DEVICE_FIDO) FidoRequestHandlerBase
   using AddPlatformAuthenticatorCallback =
       base::OnceCallback<std::unique_ptr<FidoAuthenticator>()>;
 
-  class COMPONENT_EXPORT(DEVICE_FIDO) AuthenticatorMapObserver {
+  enum class RequestType { kMakeCredential, kGetAssertion };
+
+  // Encapsulates data required to initiate WebAuthN UX dialog. Once all
+  // components of TransportAvailabilityInfo is set,
+  // AuthenticatorRequestClientDelegate should be notified.
+  // TODO(hongjunchoi): Add async calls to notify embedder when Bluetooth is
+  // powered on/off.
+  struct COMPONENT_EXPORT(DEVICE_FIDO) TransportAvailabilityInfo {
+    TransportAvailabilityInfo();
+    TransportAvailabilityInfo(const TransportAvailabilityInfo& other);
+    TransportAvailabilityInfo& operator=(
+        const TransportAvailabilityInfo& other);
+    ~TransportAvailabilityInfo();
+
+    RequestType request_type = RequestType::kMakeCredential;
+    std::set<FidoTransportProtocol> available_transports;
+    bool has_recognized_mac_touch_id_credential = false;
+    bool is_ble_powered = false;
+    bool can_power_on_ble_adapter = false;
+  };
+
+  class COMPONENT_EXPORT(DEVICE_FIDO) TransportAvailabilityObserver {
    public:
-    virtual ~AuthenticatorMapObserver();
+    virtual ~TransportAvailabilityObserver();
 
-    virtual void BluetoothAdapterIsAvailable() = 0;
+    virtual void OnTransportAvailabilityEnumerated(
+        TransportAvailabilityInfo data) = 0;
+    virtual void BluetoothAdapterPowerChanged(bool is_powered_on) = 0;
     virtual void FidoAuthenticatorAdded(
         const FidoAuthenticator& authenticator) = 0;
     virtual void FidoAuthenticatorRemoved(base::StringPiece device_id) = 0;
@@ -76,7 +100,7 @@ class COMPONENT_EXPORT(DEVICE_FIDO) FidoRequestHandlerBase
   // https://w3c.github.io/webauthn/#iface-pkcredential
   void CancelOngoingTasks(base::StringPiece exclude_device_id = nullptr);
 
-  void set_observer(AuthenticatorMapObserver* observer) {
+  void set_observer(TransportAvailabilityObserver* observer) {
     DCHECK(!observer_) << "Only one observer is supported.";
     observer_ = observer;
   }
@@ -97,8 +121,10 @@ class COMPONENT_EXPORT(DEVICE_FIDO) FidoRequestHandlerBase
   std::vector<std::unique_ptr<FidoDiscovery>>& discoveries() {
     return discoveries_;
   }
-
-  AuthenticatorMapObserver* observer() const { return observer_; }
+  TransportAvailabilityInfo& transport_availability_info() {
+    return transport_availability_info_;
+  }
+  TransportAvailabilityObserver* observer() const { return observer_; }
 
  private:
   // FidoDiscovery::Observer
@@ -108,12 +134,16 @@ class COMPONENT_EXPORT(DEVICE_FIDO) FidoRequestHandlerBase
 
   void AddAuthenticator(std::unique_ptr<FidoAuthenticator> authenticator);
   void MaybeAddPlatformAuthenticator();
+  void NotifyObserverUiData();
 
   AuthenticatorMap active_authenticators_;
   std::vector<std::unique_ptr<FidoDiscovery>> discoveries_;
-  AuthenticatorMapObserver* observer_ = nullptr;
-
+  TransportAvailabilityObserver* observer_ = nullptr;
+  TransportAvailabilityInfo transport_availability_info_;
+  base::RepeatingClosure notify_observer_callback_;
   AddPlatformAuthenticatorCallback add_platform_authenticator_;
+
+  base::WeakPtrFactory<FidoRequestHandlerBase> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(FidoRequestHandlerBase);
 };
 

device/fido/get_assertion_request_handler.cc

@@ -5,6 +5,7 @@
 #include "device/fido/get_assertion_request_handler.h"
 
 #include <algorithm>
+#include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ -115,6 +116,26 @@ bool CheckUserVerificationCompatible(FidoAuthenticator* authenticator,
   return false;
 }
 
+std::set<FidoTransportProtocol> GetAllowedTransports(
+    const CtapGetAssertionRequest& request) {
+  const auto& allowed_list = request.allow_list();
+  if (!allowed_list) {
+    return {FidoTransportProtocol::kInternal,
+            FidoTransportProtocol::kNearFieldCommunication,
+            FidoTransportProtocol::kUsbHumanInterfaceDevice,
+            FidoTransportProtocol::kBluetoothLowEnergy,
+            FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy};
+  }
+
+  std::set<FidoTransportProtocol> protocols;
+  for (const auto credential : *allowed_list) {
+    protocols.insert(credential.transports().begin(),
+                     credential.transports().end());
+  }
+
+  return protocols;
+}
+
 }  // namespace
 
 GetAssertionRequestHandler::GetAssertionRequestHandler(
@@ -149,6 +170,10 @@ GetAssertionRequestHandler::GetAssertionRequestHandler(
     discoveries().push_back(std::move(discovery));
   }
 
+  transport_availability_info().request_type =
+      FidoRequestHandlerBase::RequestType::kGetAssertion;
+  transport_availability_info().available_transports =
+      GetAllowedTransports(request_);
   Start();
 }
 

device/fido/make_credential_request_handler.cc

@@ -4,50 +4,19 @@
 
 #include "device/fido/make_credential_request_handler.h"
 
+#include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "device/fido/authenticator_make_credential_response.h"
 #include "device/fido/fido_authenticator.h"
 #include "device/fido/fido_parsing_utils.h"
+#include "device/fido/fido_transport_protocol.h"
 #include "device/fido/make_credential_task.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 namespace device {
 
-MakeCredentialRequestHandler::MakeCredentialRequestHandler(
-    service_manager::Connector* connector,
-    const base::flat_set<FidoTransportProtocol>& protocols,
-    CtapMakeCredentialRequest request,
-    AuthenticatorSelectionCriteria authenticator_selection_criteria,
-    RegisterResponseCallback completion_callback)
-    : MakeCredentialRequestHandler(connector,
-                                   protocols,
-                                   std::move(request),
-                                   authenticator_selection_criteria,
-                                   std::move(completion_callback),
-                                   AddPlatformAuthenticatorCallback()) {}
-
-MakeCredentialRequestHandler::MakeCredentialRequestHandler(
-    service_manager::Connector* connector,
-    const base::flat_set<FidoTransportProtocol>& protocols,
-    CtapMakeCredentialRequest request,
-    AuthenticatorSelectionCriteria authenticator_selection_criteria,
-    RegisterResponseCallback completion_callback,
-    AddPlatformAuthenticatorCallback add_platform_authenticator)
-    : FidoRequestHandler(connector,
-                         protocols,
-                         std::move(completion_callback),
-                         std::move(add_platform_authenticator)),
-      request_parameter_(std::move(request)),
-      authenticator_selection_criteria_(
-          std::move(authenticator_selection_criteria)),
-      weak_factory_(this) {
-  Start();
-}
-
-MakeCredentialRequestHandler::~MakeCredentialRequestHandler() = default;
-
 namespace {
 
 bool CheckIfAuthenticatorSelectionCriteriaAreSatisfied(
@@ -88,8 +57,71 @@ bool CheckIfAuthenticatorSelectionCriteriaAreSatisfied(
              UvAvailability::kSupportedAndConfigured;
 }
 
+std::set<FidoTransportProtocol> GetValidTransportProtocols(
+    const AuthenticatorSelectionCriteria& authenticator_selection_criteria) {
+  using AttachmentType =
+      AuthenticatorSelectionCriteria::AuthenticatorAttachment;
+  const auto attachment_type =
+      authenticator_selection_criteria.authenticator_attachement();
+  switch (attachment_type) {
+    case AttachmentType::kPlatform:
+      return {FidoTransportProtocol::kInternal};
+    case AttachmentType::kCrossPlatform:
+      return {FidoTransportProtocol::kUsbHumanInterfaceDevice,
+              FidoTransportProtocol::kBluetoothLowEnergy,
+              FidoTransportProtocol::kNearFieldCommunication,
+              FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy};
+    case AttachmentType::kAny:
+      return {FidoTransportProtocol::kInternal,
+              FidoTransportProtocol::kNearFieldCommunication,
+              FidoTransportProtocol::kUsbHumanInterfaceDevice,
+              FidoTransportProtocol::kBluetoothLowEnergy,
+              FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy};
+  }
+
+  NOTREACHED();
+  return std::set<FidoTransportProtocol>();
+}
+
 }  // namespace
 
+MakeCredentialRequestHandler::MakeCredentialRequestHandler(
+    service_manager::Connector* connector,
+    const base::flat_set<FidoTransportProtocol>& protocols,
+    CtapMakeCredentialRequest request,
+    AuthenticatorSelectionCriteria authenticator_selection_criteria,
+    RegisterResponseCallback completion_callback)
+    : MakeCredentialRequestHandler(connector,
+                                   protocols,
+                                   std::move(request),
+                                   authenticator_selection_criteria,
+                                   std::move(completion_callback),
+                                   AddPlatformAuthenticatorCallback()) {}
+
+MakeCredentialRequestHandler::MakeCredentialRequestHandler(
+    service_manager::Connector* connector,
+    const base::flat_set<FidoTransportProtocol>& protocols,
+    CtapMakeCredentialRequest request,
+    AuthenticatorSelectionCriteria authenticator_selection_criteria,
+    RegisterResponseCallback completion_callback,
+    AddPlatformAuthenticatorCallback add_platform_authenticator)
+    : FidoRequestHandler(connector,
+                         protocols,
+                         std::move(completion_callback),
+                         std::move(add_platform_authenticator)),
+      request_parameter_(std::move(request)),
+      authenticator_selection_criteria_(
+          std::move(authenticator_selection_criteria)),
+      weak_factory_(this) {
+  transport_availability_info().request_type =
+      FidoRequestHandlerBase::RequestType::kMakeCredential;
+  transport_availability_info().available_transports =
+      GetValidTransportProtocols(authenticator_selection_criteria);
+  Start();
+}
+
+MakeCredentialRequestHandler::~MakeCredentialRequestHandler() = default;
+
 void MakeCredentialRequestHandler::DispatchRequest(
     FidoAuthenticator* authenticator) {
   // The user verification field of the request may be adjusted to the