libhwsec/middleware/middleware.h - third_party/platform2 - Git at Google

 // Copyright 2022 The ChromiumOS Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef LIBHWSEC_MIDDLEWARE_MIDDLEWARE_H_
 #define LIBHWSEC_MIDDLEWARE_MIDDLEWARE_H_

 #include <concepts>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <variant>

 #include <absl/base/attributes.h>
 #include <base/functional/callback.h>
 #include <base/functional/callback_helpers.h>
 #include <base/logging.h>
 #include <base/memory/scoped_refptr.h>
 #include <base/memory/weak_ptr.h>
 #include <base/strings/stringprintf.h>
 #include <base/task/bind_post_task.h>
 #include <base/task/sequenced_task_runner.h>
 #include <base/task/single_thread_task_runner.h>
 #include <base/task/task_runner.h>
 #include <base/threading/thread.h>

 #include "libhwsec/backend/backend.h"
 #include "libhwsec/error/tpm_retry_action.h"
 #include "libhwsec/error/tpm_retry_handler.h"
 #include "libhwsec/middleware/function_name.h"
 #include "libhwsec/middleware/middleware_derivative.h"
 #include "libhwsec/middleware/middleware_owner.h"
 #include "libhwsec/middleware/subclass_helper.h"
 #include "libhwsec/proxy/proxy.h"
 #include "libhwsec/status.h"

 #ifndef BUILD_LIBHWSEC
 #error "Don't include this file outside libhwsec!"
 #endif

 // Middleware can be shared by multiple frontends.
 // Converts asynchronous and synchronous calls to the backend.
 // And doing some generic error handling, for example: communication error and
 // auto reload key & session.
 //
 // Note: The middleware can maintain a standalone thread, or use the same task
 // runner as the caller side.
 //
 // Note2: The move-only function parameters would not be copied, the other kinds
 // of function parameters would be copied due to base::BindOnce.

 namespace hwsec {

 class Middleware {
  public:
   explicit Middleware(MiddlewareDerivative middleware_derivative)
       : middleware_derivative_(middleware_derivative) {}

   MiddlewareDerivative Derive() const { return middleware_derivative_; }

   // Call the backend function synchronously.
   template <auto Func, typename... Args>
     requires(BackendMethod<decltype(Func)> &&
              ValidBackendMethodArgs<decltype(Func), Args...>)
   auto CallSync(Args&&... args) const {
     return CallSyncInternal<Func>(std::forward<Args>(args)...);
   }

   // Call the backend function asynchronously.
   template <auto Func, typename Callback, typename... Args>
     requires(BackendMethod<decltype(Func)> &&
              ValidBackendMethodArgs<decltype(Func), Args...>)
   void CallAsync(Callback callback, Args&&... args) const {
     CHECK(middleware_derivative_.task_runner);

     SubClassCallback<decltype(Func)> reply = std::move(callback);
     reply = base::BindPostTask(GetReplyRunner(), std::move(reply));
     base::OnceClosure task = base::BindOnce(
         &Middleware::CallAsyncInternal<Func, decltype(ForwardParameter(
                                                  std::declval<Args>()))...>,
         middleware_derivative_.middleware, std::move(reply),
         ForwardParameter(std::forward<Args>(args))...);
     middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(task));
   }

   // Run a blocking task without return value in the middleware.
   void RunBlockingTask(base::OnceCallback<void()> task) const {
     if (middleware_derivative_.thread_id == base::PlatformThread::CurrentId()) {
       return std::move(task).Run();
     }

     CHECK(middleware_derivative_.task_runner);

     base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                               base::WaitableEvent::InitialState::NOT_SIGNALED);

     base::OnceClosure closure = std::move(task).Then(
         base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&event)));
     middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(closure));
     event.Wait();
     return;
   }

   // Run a blocking task with return value in the middleware.
   template <typename Result>
     requires(std::constructible_from<Result, Status>)
   Result RunBlockingTask(base::OnceCallback<Result()> task) const {
     if (middleware_derivative_.thread_id == base::PlatformThread::CurrentId()) {
       return std::move(task).Run();
     }

     CHECK(middleware_derivative_.task_runner);

     base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                               base::WaitableEvent::InitialState::NOT_SIGNALED);

     using hwsec_foundation::status::MakeStatus;
     Result result =
         MakeStatus<TPMError>("Unknown error", TPMRetryAction::kNoRetry);
     base::OnceClosure closure =
         std::move(task)
             .Then(base::BindOnce(
                 [](Result* result_ptr, Result value) {
                   *result_ptr = std::move(value);
                 },
                 &result))
             .Then(base::BindOnce(&base::WaitableEvent::Signal,
                                  base::Unretained(&event)));
     middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(closure));
     event.Wait();
     return result;
   }

  private:
   // Get the quick result that is not related to the function itself.
   template <auto Func>
     requires(BackendMethod<decltype(Func)>)
   static std::variant<SubClassResult<decltype(Func)>,
                       SubClassType<decltype(Func)>*>
   GetQuickResult(base::WeakPtr<MiddlewareOwner> middleware) {
     using hwsec_foundation::status::MakeStatus;

     if (!middleware) {
       return MakeStatus<TPMError>("No middleware", TPMRetryAction::kNoRetry);
     }

 #if USE_FUZZER
     if (middleware->data_provider_) {
       return FuzzedObject<SubClassResult<decltype(Func)>>()(
           *middleware->data_provider_);
     }
 #endif

     if (!middleware->GetBackend()) {
       return MakeStatus<TPMError>("No backend", TPMRetryAction::kNoRetry);
     }

     auto* sub = middleware->GetBackend()->Get<SubClassType<decltype(Func)>>();
     if (!sub) {
       return MakeStatus<TPMError>("No sub class in backend",
                                   TPMRetryAction::kNoRetry);
     }

     return sub;
   }

   // Call the synchronous backend call.
   template <auto Func, typename... Args>
     requires(SyncBackendMethod<decltype(Func)>)
   static SubClassResult<decltype(Func)> DoSyncBackendCall(
       base::WeakPtr<MiddlewareOwner> middleware, Args... args) {
     using Result = SubClassResult<decltype(Func)>;
     using Type = SubClassType<decltype(Func)>;

     std::variant<Result, Type*> quick_result = GetQuickResult<Func>(middleware);
     if (Result* result = std::get_if<Result>(&quick_result)) {
       return std::move(*result);
     }

     Type* sub = *std::get_if<Type*>(&quick_result);

     for (TPMRetryHandler retry_handler;;) {
       SubClassResult<decltype(Func)> result = (sub->*Func)(args...);

       TrackFuncResult(GetFuncName<Func>(), middleware->GetMetrics(), result);

       if (retry_handler.HandleResult(result, *middleware->GetBackend(),
                                      middleware->GetMetrics(), args...)) {
         return result;
       }
     }
   }

   // Call the asynchronous backend call.
   template <auto Func, typename... Args>
     requires(AsyncBackendMethod<decltype(Func)>)
   static void DoAsyncBackendCall(base::WeakPtr<MiddlewareOwner> middleware,
                                  SubClassCallback<decltype(Func)> callback,
                                  Args... args) {
     auto retry_handler = std::make_unique<TPMRetryHandler>();

     // Using the decay type to make sure we are not putting dangling reference
     // in the tuple.
     auto args_tuple =
         std::make_unique<std::tuple<std::decay_t<Args>...>>(std::move(args)...);

     DoAsyncBackendCallInternal<Func>(
         std::move(middleware), std::move(retry_handler), std::move(callback),
         std::move(args_tuple), std::make_index_sequence<sizeof...(Args)>());
   }

   template <auto Func, typename ArgsTuple, std::size_t... I>
     requires(AsyncBackendMethod<decltype(Func)>)
   static void DoAsyncBackendCallInternal(
       base::WeakPtr<MiddlewareOwner> middleware,
       std::unique_ptr<TPMRetryHandler> retry_handler,
       SubClassCallback<decltype(Func)> callback,
       std::unique_ptr<ArgsTuple> args,
       std::index_sequence<I...> idx_seq) {
     using Result = SubClassResult<decltype(Func)>;
     using Type = SubClassType<decltype(Func)>;
     using Callback = SubClassCallback<decltype(Func)>;

     std::variant<Result, Type*> quick_result = GetQuickResult<Func>(middleware);
     if (Result* result = std::get_if<Result>(&quick_result)) {
       std::move(callback).Run(std::move(*result));
       return;
     }

     Type* sub = *std::get_if<Type*>(&quick_result);

     // Note: The args tuple will be owned by the retry callback.
     // We will transfer the ownership of the retry callback into the backend
     // function, so the backend functions should be careful about not using the
     // args after call or drop the callback.
     ArgsTuple& args_ref = *args;

     Callback retry_callback =
         base::BindOnce(&HandleAsyncBackendCallRetry<Func, ArgsTuple, I...>,
                        std::move(middleware), std::move(retry_handler),
                        std::move(callback), std::move(args), idx_seq);

     (sub->*Func)(std::move(retry_callback), std::get<I>(args_ref)...);
   }

   template <auto Func, typename ArgsTuple, std::size_t... I>
     requires(AsyncBackendMethod<decltype(Func)>)
   static void HandleAsyncBackendCallRetry(
       base::WeakPtr<MiddlewareOwner> middleware,
       std::unique_ptr<TPMRetryHandler> retry_handler,
       SubClassCallback<decltype(Func)> callback,
       std::unique_ptr<ArgsTuple> args,
       std::index_sequence<I...> idx_seq,
       SubClassResult<decltype(Func)> result) {
     using hwsec_foundation::status::MakeStatus;

     if (!middleware) {
       std::move(callback).Run(
           MakeStatus<TPMError>("No middleware", TPMRetryAction::kNoRetry));
       return;
     }

     TrackFuncResult(GetFuncName<Func>(), middleware->GetMetrics(), result);

     if (retry_handler->HandleResult(result, *middleware->GetBackend(),
                                     middleware->GetMetrics(),
                                     std::get<I>(*args)...)) {
       std::move(callback).Run(std::move(result));
       return;
     }

     DoAsyncBackendCallInternal<Func>(
         std::move(middleware), std::move(retry_handler), std::move(callback),
         std::move(args), idx_seq);
   }

   // Call the synchronous backend function synchronously.
   template <auto Func, typename... Args>
     requires(SyncBackendMethod<decltype(Func)>)
   auto CallSyncInternal(Args&&... args) const {
     // Calling sync backend function.
     auto task = base::BindOnce(
         &Middleware::DoSyncBackendCall<Func, decltype(ForwardParameter(
                                                  std::declval<Args>()))...>,
         middleware_derivative_.middleware,
         ForwardParameter(std::forward<Args>(args))...);
     return RunBlockingTask(std::move(task));
   }

   // Call the asynchronous backend function synchronously.
   template <auto Func, typename... Args>
     requires(AsyncBackendMethod<decltype(Func)>)
   auto CallSyncInternal(Args&&... args) const {
     // Calling async backend function.
     using hwsec_foundation::status::MakeStatus;
     using Result = SubClassResult<decltype(Func)>;
     using Callback = SubClassCallback<decltype(Func)>;

     base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                               base::WaitableEvent::InitialState::NOT_SIGNALED);

     Result result =
         MakeStatus<TPMError>("Unknown error", TPMRetryAction::kNoRetry);
     Callback callback =
         base::BindOnce([](Result* result_ptr,
                           Result value) { *result_ptr = std::move(value); },
                        &result)
             .Then(base::BindOnce(&base::WaitableEvent::Signal,
                                  base::Unretained(&event)));

     base::OnceClosure task = base::BindOnce(
         &Middleware::DoAsyncBackendCall<Func, decltype(ForwardParameter(
                                                   std::declval<Args>()))...>,
         middleware_derivative_.middleware, std::move(callback),
         ForwardParameter(std::forward<Args>(args))...);

     middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(task));
     event.Wait();
     return result;
   }

   // Calling synchronous backend function asynchronously.
   template <auto Func, typename... Args>
     requires(SyncBackendMethod<decltype(Func)>)
   static void CallAsyncInternal(base::WeakPtr<MiddlewareOwner> middleware,
                                 SubClassCallback<decltype(Func)> callback,
                                 Args... args) {
     std::move(callback).Run(DoSyncBackendCall<Func, Args...>(
         std::move(middleware), ForwardParameter(std::move(args))...));
   }

   // Calling asynchronous backend function asynchronously.
   template <auto Func, typename... Args>
     requires(AsyncBackendMethod<decltype(Func)>)
   static void CallAsyncInternal(base::WeakPtr<MiddlewareOwner> middleware,
                                 SubClassCallback<decltype(Func)> callback,
                                 Args... args) {
     Middleware::DoAsyncBackendCall<Func, Args...>(
         std::move(middleware), std::move(callback),
         ForwardParameter(std::move(args))...);
   }

   template <typename Result>
     requires(std::constructible_from<Result, Status>)
   static void TrackFuncResult(const std::string& function_name,
                               Metrics* metrics,
                               Result& result) {
     using hwsec_foundation::status::MakeStatus;

     std::string sim_name = SimplifyFuncName(function_name);

     if (metrics) {
       metrics->SendFuncResultToUMA(sim_name, result.status());
     }

     if (!result.ok()) {
       Status status = std::move(result).err_status();
       TPMRetryAction action = status->ToTPMRetryAction();
       status = MakeStatus<TPMError>(
                    base::StringPrintf("%s(%s)", sim_name.c_str(),
                                       GetTPMRetryActionName(action)),
                    action)
                    .Wrap(std::move(status));
       result = std::move(status);
     }
   }

   static scoped_refptr<base::TaskRunner> GetReplyRunner() {
     CHECK(base::SequencedTaskRunner::HasCurrentDefault());
     return base::SequencedTaskRunner::GetCurrentDefault();
   }

   MiddlewareDerivative middleware_derivative_;
 };

 }  // namespace hwsec

 #endif  // LIBHWSEC_MIDDLEWARE_MIDDLEWARE_H_
	// Copyright 2022 The ChromiumOS Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef LIBHWSEC_MIDDLEWARE_MIDDLEWARE_H_
	#define LIBHWSEC_MIDDLEWARE_MIDDLEWARE_H_

	#include <concepts>
	#include <memory>
	#include <string>
	#include <tuple>
	#include <type_traits>
	#include <utility>
	#include <variant>

	#include <absl/base/attributes.h>
	#include <base/functional/callback.h>
	#include <base/functional/callback_helpers.h>
	#include <base/logging.h>
	#include <base/memory/scoped_refptr.h>
	#include <base/memory/weak_ptr.h>
	#include <base/strings/stringprintf.h>
	#include <base/task/bind_post_task.h>
	#include <base/task/sequenced_task_runner.h>
	#include <base/task/single_thread_task_runner.h>
	#include <base/task/task_runner.h>
	#include <base/threading/thread.h>

	#include "libhwsec/backend/backend.h"
	#include "libhwsec/error/tpm_retry_action.h"
	#include "libhwsec/error/tpm_retry_handler.h"
	#include "libhwsec/middleware/function_name.h"
	#include "libhwsec/middleware/middleware_derivative.h"
	#include "libhwsec/middleware/middleware_owner.h"
	#include "libhwsec/middleware/subclass_helper.h"
	#include "libhwsec/proxy/proxy.h"
	#include "libhwsec/status.h"

	#ifndef BUILD_LIBHWSEC
	#error "Don't include this file outside libhwsec!"
	#endif

	// Middleware can be shared by multiple frontends.
	// Converts asynchronous and synchronous calls to the backend.
	// And doing some generic error handling, for example: communication error and
	// auto reload key & session.
	//
	// Note: The middleware can maintain a standalone thread, or use the same task
	// runner as the caller side.
	//
	// Note2: The move-only function parameters would not be copied, the other kinds
	// of function parameters would be copied due to base::BindOnce.

	namespace hwsec {

	class Middleware {
	public:
	explicit Middleware(MiddlewareDerivative middleware_derivative)
	: middleware_derivative_(middleware_derivative) {}

	MiddlewareDerivative Derive() const { return middleware_derivative_; }

	// Call the backend function synchronously.
	template <auto Func, typename... Args>
	requires(BackendMethod<decltype(Func)> &&
	ValidBackendMethodArgs<decltype(Func), Args...>)
	auto CallSync(Args&&... args) const {
	return CallSyncInternal<Func>(std::forward<Args>(args)...);
	}

	// Call the backend function asynchronously.
	template <auto Func, typename Callback, typename... Args>
	requires(BackendMethod<decltype(Func)> &&
	ValidBackendMethodArgs<decltype(Func), Args...>)
	void CallAsync(Callback callback, Args&&... args) const {
	CHECK(middleware_derivative_.task_runner);

	SubClassCallback<decltype(Func)> reply = std::move(callback);
	reply = base::BindPostTask(GetReplyRunner(), std::move(reply));
	base::OnceClosure task = base::BindOnce(
	&Middleware::CallAsyncInternal<Func, decltype(ForwardParameter(
	std::declval<Args>()))...>,
	middleware_derivative_.middleware, std::move(reply),
	ForwardParameter(std::forward<Args>(args))...);
	middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(task));
	}

	// Run a blocking task without return value in the middleware.
	void RunBlockingTask(base::OnceCallback<void()> task) const {
	if (middleware_derivative_.thread_id == base::PlatformThread::CurrentId()) {
	return std::move(task).Run();
	}

	CHECK(middleware_derivative_.task_runner);

	base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
	base::WaitableEvent::InitialState::NOT_SIGNALED);

	base::OnceClosure closure = std::move(task).Then(
	base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&event)));
	middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(closure));
	event.Wait();
	return;
	}

	// Run a blocking task with return value in the middleware.
	template <typename Result>
	requires(std::constructible_from<Result, Status>)
	Result RunBlockingTask(base::OnceCallback<Result()> task) const {
	if (middleware_derivative_.thread_id == base::PlatformThread::CurrentId()) {
	return std::move(task).Run();
	}

	CHECK(middleware_derivative_.task_runner);

	base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
	base::WaitableEvent::InitialState::NOT_SIGNALED);

	using hwsec_foundation::status::MakeStatus;
	Result result =
	MakeStatus<TPMError>("Unknown error", TPMRetryAction::kNoRetry);
	base::OnceClosure closure =
	std::move(task)
	.Then(base::BindOnce(
	[](Result* result_ptr, Result value) {
	*result_ptr = std::move(value);
	},
	&result))
	.Then(base::BindOnce(&base::WaitableEvent::Signal,
	base::Unretained(&event)));
	middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(closure));
	event.Wait();
	return result;
	}

	private:
	// Get the quick result that is not related to the function itself.
	template <auto Func>
	requires(BackendMethod<decltype(Func)>)
	static std::variant<SubClassResult<decltype(Func)>,
	SubClassType<decltype(Func)>*>
	GetQuickResult(base::WeakPtr<MiddlewareOwner> middleware) {
	using hwsec_foundation::status::MakeStatus;

	if (!middleware) {
	return MakeStatus<TPMError>("No middleware", TPMRetryAction::kNoRetry);
	}

	#if USE_FUZZER
	if (middleware->data_provider_) {
	return FuzzedObject<SubClassResult<decltype(Func)>>()(
	*middleware->data_provider_);
	}
	#endif

	if (!middleware->GetBackend()) {
	return MakeStatus<TPMError>("No backend", TPMRetryAction::kNoRetry);
	}

	auto* sub = middleware->GetBackend()->Get<SubClassType<decltype(Func)>>();
	if (!sub) {
	return MakeStatus<TPMError>("No sub class in backend",
	TPMRetryAction::kNoRetry);
	}

	return sub;
	}

	// Call the synchronous backend call.
	template <auto Func, typename... Args>
	requires(SyncBackendMethod<decltype(Func)>)
	static SubClassResult<decltype(Func)> DoSyncBackendCall(
	base::WeakPtr<MiddlewareOwner> middleware, Args... args) {
	using Result = SubClassResult<decltype(Func)>;
	using Type = SubClassType<decltype(Func)>;

	std::variant<Result, Type*> quick_result = GetQuickResult<Func>(middleware);
	if (Result* result = std::get_if<Result>(&quick_result)) {
	return std::move(*result);
	}

	Type* sub = std::get_if<Type>(&quick_result);

	for (TPMRetryHandler retry_handler;;) {
	SubClassResult<decltype(Func)> result = (sub->*Func)(args...);

	TrackFuncResult(GetFuncName<Func>(), middleware->GetMetrics(), result);

	if (retry_handler.HandleResult(result, *middleware->GetBackend(),
	middleware->GetMetrics(), args...)) {
	return result;
	}
	}
	}

	// Call the asynchronous backend call.
	template <auto Func, typename... Args>
	requires(AsyncBackendMethod<decltype(Func)>)
	static void DoAsyncBackendCall(base::WeakPtr<MiddlewareOwner> middleware,
	SubClassCallback<decltype(Func)> callback,
	Args... args) {
	auto retry_handler = std::make_unique<TPMRetryHandler>();

	// Using the decay type to make sure we are not putting dangling reference
	// in the tuple.
	auto args_tuple =
	std::make_unique<std::tuple<std::decay_t<Args>...>>(std::move(args)...);

	DoAsyncBackendCallInternal<Func>(
	std::move(middleware), std::move(retry_handler), std::move(callback),
	std::move(args_tuple), std::make_index_sequence<sizeof...(Args)>());
	}

	template <auto Func, typename ArgsTuple, std::size_t... I>
	requires(AsyncBackendMethod<decltype(Func)>)
	static void DoAsyncBackendCallInternal(
	base::WeakPtr<MiddlewareOwner> middleware,
	std::unique_ptr<TPMRetryHandler> retry_handler,
	SubClassCallback<decltype(Func)> callback,
	std::unique_ptr<ArgsTuple> args,
	std::index_sequence<I...> idx_seq) {
	using Result = SubClassResult<decltype(Func)>;
	using Type = SubClassType<decltype(Func)>;
	using Callback = SubClassCallback<decltype(Func)>;

	std::variant<Result, Type*> quick_result = GetQuickResult<Func>(middleware);
	if (Result* result = std::get_if<Result>(&quick_result)) {
	std::move(callback).Run(std::move(*result));
	return;
	}

	Type* sub = std::get_if<Type>(&quick_result);

	// Note: The args tuple will be owned by the retry callback.
	// We will transfer the ownership of the retry callback into the backend
	// function, so the backend functions should be careful about not using the
	// args after call or drop the callback.
	ArgsTuple& args_ref = *args;

	Callback retry_callback =
	base::BindOnce(&HandleAsyncBackendCallRetry<Func, ArgsTuple, I...>,
	std::move(middleware), std::move(retry_handler),
	std::move(callback), std::move(args), idx_seq);

	(sub->*Func)(std::move(retry_callback), std::get<I>(args_ref)...);
	}

	template <auto Func, typename ArgsTuple, std::size_t... I>
	requires(AsyncBackendMethod<decltype(Func)>)
	static void HandleAsyncBackendCallRetry(
	base::WeakPtr<MiddlewareOwner> middleware,
	std::unique_ptr<TPMRetryHandler> retry_handler,
	SubClassCallback<decltype(Func)> callback,
	std::unique_ptr<ArgsTuple> args,
	std::index_sequence<I...> idx_seq,
	SubClassResult<decltype(Func)> result) {
	using hwsec_foundation::status::MakeStatus;

	if (!middleware) {
	std::move(callback).Run(
	MakeStatus<TPMError>("No middleware", TPMRetryAction::kNoRetry));
	return;
	}

	TrackFuncResult(GetFuncName<Func>(), middleware->GetMetrics(), result);

	if (retry_handler->HandleResult(result, *middleware->GetBackend(),
	middleware->GetMetrics(),
	std::get<I>(*args)...)) {
	std::move(callback).Run(std::move(result));
	return;
	}

	DoAsyncBackendCallInternal<Func>(
	std::move(middleware), std::move(retry_handler), std::move(callback),
	std::move(args), idx_seq);
	}

	// Call the synchronous backend function synchronously.
	template <auto Func, typename... Args>
	requires(SyncBackendMethod<decltype(Func)>)
	auto CallSyncInternal(Args&&... args) const {
	// Calling sync backend function.
	auto task = base::BindOnce(
	&Middleware::DoSyncBackendCall<Func, decltype(ForwardParameter(
	std::declval<Args>()))...>,
	middleware_derivative_.middleware,
	ForwardParameter(std::forward<Args>(args))...);
	return RunBlockingTask(std::move(task));
	}

	// Call the asynchronous backend function synchronously.
	template <auto Func, typename... Args>
	requires(AsyncBackendMethod<decltype(Func)>)
	auto CallSyncInternal(Args&&... args) const {
	// Calling async backend function.
	using hwsec_foundation::status::MakeStatus;
	using Result = SubClassResult<decltype(Func)>;
	using Callback = SubClassCallback<decltype(Func)>;

	base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
	base::WaitableEvent::InitialState::NOT_SIGNALED);

	Result result =
	MakeStatus<TPMError>("Unknown error", TPMRetryAction::kNoRetry);
	Callback callback =
	base::BindOnce([](Result* result_ptr,
	Result value) { *result_ptr = std::move(value); },
	&result)
	.Then(base::BindOnce(&base::WaitableEvent::Signal,
	base::Unretained(&event)));

	base::OnceClosure task = base::BindOnce(
	&Middleware::DoAsyncBackendCall<Func, decltype(ForwardParameter(
	std::declval<Args>()))...>,
	middleware_derivative_.middleware, std::move(callback),
	ForwardParameter(std::forward<Args>(args))...);

	middleware_derivative_.task_runner->PostTask(FROM_HERE, std::move(task));
	event.Wait();
	return result;
	}

	// Calling synchronous backend function asynchronously.
	template <auto Func, typename... Args>
	requires(SyncBackendMethod<decltype(Func)>)
	static void CallAsyncInternal(base::WeakPtr<MiddlewareOwner> middleware,
	SubClassCallback<decltype(Func)> callback,
	Args... args) {
	std::move(callback).Run(DoSyncBackendCall<Func, Args...>(
	std::move(middleware), ForwardParameter(std::move(args))...));
	}

	// Calling asynchronous backend function asynchronously.
	template <auto Func, typename... Args>
	requires(AsyncBackendMethod<decltype(Func)>)
	static void CallAsyncInternal(base::WeakPtr<MiddlewareOwner> middleware,
	SubClassCallback<decltype(Func)> callback,
	Args... args) {
	Middleware::DoAsyncBackendCall<Func, Args...>(
	std::move(middleware), std::move(callback),
	ForwardParameter(std::move(args))...);
	}

	template <typename Result>
	requires(std::constructible_from<Result, Status>)
	static void TrackFuncResult(const std::string& function_name,
	Metrics* metrics,
	Result& result) {
	using hwsec_foundation::status::MakeStatus;

	std::string sim_name = SimplifyFuncName(function_name);

	if (metrics) {
	metrics->SendFuncResultToUMA(sim_name, result.status());
	}

	if (!result.ok()) {
	Status status = std::move(result).err_status();
	TPMRetryAction action = status->ToTPMRetryAction();
	status = MakeStatus<TPMError>(
	base::StringPrintf("%s(%s)", sim_name.c_str(),
	GetTPMRetryActionName(action)),
	action)
	.Wrap(std::move(status));
	result = std::move(status);
	}
	}

	static scoped_refptr<base::TaskRunner> GetReplyRunner() {
	CHECK(base::SequencedTaskRunner::HasCurrentDefault());
	return base::SequencedTaskRunner::GetCurrentDefault();
	}

	MiddlewareDerivative middleware_derivative_;
	};

	} // namespace hwsec

	#endif // LIBHWSEC_MIDDLEWARE_MIDDLEWARE_H_