Bug 1731977 - Add MOZ_TO_RESULT_INVOKE_TYPED for invoking plain functions; r=dom-storage-reviewers,jari

Differential Revision: https://phabricator.services.mozilla.com/D126329

dom/indexedDB/ActorsParentCommon.cpp

@@ -635,8 +635,9 @@ nsresult ReadCompressedIndexDataValues(
 template <typename T>
 Result<IndexDataValuesAutoArray, nsresult> ReadCompressedIndexDataValues(
     T& aValues, uint32_t aColumnIndex) {
-  return ToResultInvoke<IndexDataValuesAutoArray>(
-      &ReadCompressedIndexDataValuesFromSource<T>, aValues, aColumnIndex);
+  return MOZ_TO_RESULT_INVOKE_TYPED(IndexDataValuesAutoArray,
+                                    &ReadCompressedIndexDataValuesFromSource<T>,
+                                    aValues, aColumnIndex);
 }
 
 template Result<IndexDataValuesAutoArray, nsresult>

dom/quota/ActorsParent.cpp

@@ -3703,8 +3703,9 @@ nsresult QuotaManager::Init() {
       GetPathForStorage(*baseDir, nsLiteralString(DEFAULT_DIRECTORY_NAME)));
 
   QM_TRY_UNWRAP(do_Init(mIOThread),
-                ToResultInvoke<nsCOMPtr<nsIThread>>(
-                    MOZ_SELECT_OVERLOAD(NS_NewNamedThread), "QuotaManager IO"));
+                MOZ_TO_RESULT_INVOKE_TYPED(
+                    nsCOMPtr<nsIThread>, MOZ_SELECT_OVERLOAD(NS_NewNamedThread),
+                    "QuotaManager IO"));
 
   // Make a timer here to avoid potential failures later. We don't actually
   // initialize the timer until shutdown.

dom/quota/QuotaCommon.cpp

@@ -119,13 +119,14 @@ void CacheUseDOSDevicePathSyntaxPrefValue() {
 #endif
 
 Result<nsCOMPtr<nsIFile>, nsresult> QM_NewLocalFile(const nsAString& aPath) {
-  QM_TRY_UNWRAP(auto file,
-                ToResultInvoke<nsCOMPtr<nsIFile>>(NS_NewLocalFile, aPath,
-                                                  /* aFollowLinks */ false),
-                QM_PROPAGATE, [&aPath](const nsresult rv) {
-                  QM_WARNING("Failed to construct a file for path (%s)",
-                             NS_ConvertUTF16toUTF8(aPath).get());
-                });
+  QM_TRY_UNWRAP(
+      auto file,
+      MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<nsIFile>, NS_NewLocalFile, aPath,
+                                 /* aFollowLinks */ false),
+      QM_PROPAGATE, [&aPath](const nsresult rv) {
+        QM_WARNING("Failed to construct a file for path (%s)",
+                   NS_ConvertUTF16toUTF8(aPath).get());
+      });
 
 #ifdef XP_WIN
   MOZ_ASSERT(gUseDOSDevicePathSyntax != -1);

dom/quota/ResultExtensions.h

@@ -109,6 +109,9 @@ Result<R, nsresult> ToResultGet(const Func& aFunc, Args&&... aArgs) {
 #define MOZ_TO_RESULT_GET_TYPED(resultType, ...) \
   ::mozilla::ToResultGet<MOZ_REMOVE_PAREN(resultType)>(__VA_ARGS__)
 
+#define MOZ_TO_RESULT_INVOKE_TYPED(resultType, ...) \
+  ::mozilla::ToResultInvoke<MOZ_REMOVE_PAREN(resultType)>(__VA_ARGS__)
+
 #define QM_TO_RESULT_INVOKE_MEMBER(obj, methodname, ...)                 \
   ::mozilla::ToResultInvokeMember<QMResult>(                             \
       (obj), &::mozilla::detail::DerefedType<decltype(obj)>::methodname, \

dom/quota/test/gtest/TestResultExtensions.cpp

@@ -12,6 +12,21 @@
 using namespace mozilla;
 using namespace mozilla::dom::quota;
 
+namespace {
+class TestClass {
+ public:
+  static constexpr int kTestValue = 42;
+
+  nsresult NonOverloadedNoInputComplex(std::pair<int, int>* aOut) {
+    *aOut = std::pair{kTestValue, kTestValue};
+    return NS_OK;
+  }
+  nsresult NonOverloadedNoInputFailsComplex(std::pair<int, int>* aOut) {
+    return NS_ERROR_FAILURE;
+  }
+};
+}  // namespace
+
 class DOM_Quota_ResultExtensions_ToResult : public DOM_Quota_Test {};
 class DOM_Quota_ResultExtensions_GenericErrorResult : public DOM_Quota_Test {};
 
@@ -238,3 +253,64 @@ TEST(DOM_Quota_ResultExtensions_ToResultGet, Lambda_WithInput_Err_Macro_Typed)
   EXPECT_TRUE(res.isErr());
   EXPECT_EQ(res.unwrapErr(), NS_ERROR_FAILURE);
 }
+
+TEST(DOM_Quota_ResultExtensions_ToResultInvoke, Lambda_NoInput_Complex)
+{
+  TestClass foo;
+
+  // success
+  {
+    auto valOrErr =
+        ToResultInvoke<std::pair<int, int>>([&foo](std::pair<int, int>* out) {
+          return foo.NonOverloadedNoInputComplex(out);
+        });
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isOk());
+    ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
+              valOrErr.unwrap());
+  }
+
+  // failure
+  {
+    auto valOrErr =
+        ToResultInvoke<std::pair<int, int>>([&foo](std::pair<int, int>* out) {
+          return foo.NonOverloadedNoInputFailsComplex(out);
+        });
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isErr());
+    ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
+  }
+}
+
+TEST(DOM_Quota_ResultExtensions_ToResultInvoke,
+     Lambda_NoInput_Complex_Macro_Typed)
+{
+  TestClass foo;
+
+  // success
+  {
+    auto valOrErr = MOZ_TO_RESULT_INVOKE_TYPED(
+        (std::pair<int, int>), [&foo](std::pair<int, int>* out) {
+          return foo.NonOverloadedNoInputComplex(out);
+        });
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isOk());
+    ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
+              valOrErr.unwrap());
+  }
+
+  // failure
+  {
+    auto valOrErr = MOZ_TO_RESULT_INVOKE_TYPED(
+        (std::pair<int, int>), [&foo](std::pair<int, int>* out) {
+          return foo.NonOverloadedNoInputFailsComplex(out);
+        });
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isErr());
+    ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
+  }
+}