Revert "Disallow constructing FunctionRefs from others w/compatible signatures."

Revert as it does not work with msvc22.

This reverts:
https://chromium-review.googlesource.com/c/chromium/src/+/5150374

Change-Id: I4ec5d9a762445b448b1fe988bdfe3e9e80357323
Reviewed-on: https://codereview.qt-project.org/c/qt/qtwebengine-chromium/+/559262
Reviewed-by: Peter Varga <pvarga@inf.u-szeged.hu>

Author: Michal Klocek

chromium/base/functional/function_ref.h

@@ -12,7 +12,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/functional/bind_internal.h"
-#include "base/types/is_instantiation.h"
 #include "third_party/abseil-cpp/absl/functional/function_ref.h"
 
 namespace base {
@@ -74,27 +73,7 @@ class FunctionRef<R(Args...)> {
   // `LIFETIME_BOUND` is important; since `FunctionRef` retains
   // only a reference to `functor`, `functor` must outlive `this`.
   template <typename Functor>
-    requires kCompatibleFunctor<Functor> &&
-             // Prevent this constructor from participating in overload
-             // resolution if the callable is itself an instantiation of the
-             // `FunctionRef` template.
-             //
-             // If the callable is a `FunctionRef` with exactly the same
-             // signature as us, then the copy constructor will be used instead,
-             // so this has no effect. (Note that if the constructor argument
-             // were `Functor&&`, this exclusion would be necessary to force the
-             // choice of the copy constructor over this one for non-const ref
-             // args; see https://stackoverflow.com/q/57909923.)
-             //
-             // If the callable is a `FunctionRef` with some other signature
-             // then we choose not to support binding to it at all. Conceivably
-             // we could teach our trampoline to deal with this, but this may be
-             // the sign of an object lifetime bug, and again it's not clear
-             // that this isn't just a mistake on the part of the user.
-             (!is_instantiation<FunctionRef, std::decay_t<Functor>>) &&
-             // For the same reason as the second case above, prevent
-             // construction from `absl::FunctionRef`.
-             (!is_instantiation<absl::FunctionRef, std::decay_t<Functor>>)
+    requires kCompatibleFunctor<Functor>
   // NOLINTNEXTLINE(google-explicit-constructor)
   FunctionRef(const Functor& functor LIFETIME_BOUND)
       : wrapped_func_ref_(functor) {}

chromium/base/functional/function_ref_unittest.cc

@@ -7,9 +7,7 @@
 #include <stdint.h>
 
 #include <concepts>
-#include <optional>
 
-#include "base/compiler_specific.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/abseil-cpp/absl/functional/function_ref.h"
 
@@ -70,62 +68,6 @@ TEST(FunctionRef, Method) {
   [&s](FunctionRef<int(const S*)> ref) { EXPECT_EQ(25, ref(&s)); }(&S::Method);
 }
 
-// If we construct from another `FunctionRef`, that should work fine, even if
-// the input is destroyed before we call the output. In other words, we should
-// reference the underlying callable, not the `FunctionRef`.
-//
-// We construct in a `noinline` function to maximize the chance that ASAN
-// notices the use-after-free if we get this wrong.
-NOINLINE void ConstructFromLValue(std::optional<FunctionRef<int()>>& ref) {
-  const auto return_17 = [] { return 17; };
-  FunctionRef<int()> other = return_17;
-  ref.emplace(other);
-}
-NOINLINE void ConstructFromConstLValue(std::optional<FunctionRef<int()>>& ref) {
-  const auto return_17 = [] { return 17; };
-  const FunctionRef<int()> other = return_17;
-  ref.emplace(other);
-}
-NOINLINE void ConstructFromRValue(std::optional<FunctionRef<int()>>& ref) {
-  const auto return_17 = [] { return 17; };
-  using Ref = FunctionRef<int()>;
-  ref.emplace(Ref(return_17));
-}
-NOINLINE void ConstructFromConstRValue(std::optional<FunctionRef<int()>>& ref) {
-  const auto return_17 = [] { return 17; };
-  using Ref = const FunctionRef<int()>;
-  ref.emplace(Ref(return_17));
-}
-TEST(FunctionRef, ConstructionFromOtherFunctionRefObjects) {
-  using Ref = FunctionRef<int()>;
-  std::optional<Ref> ref;
-
-  ConstructFromLValue(ref);
-  EXPECT_EQ(17, (*ref)());
-
-  ConstructFromConstLValue(ref);
-  EXPECT_EQ(17, (*ref)());
-
-  ConstructFromRValue(ref);
-  EXPECT_EQ(17, (*ref)());
-
-  ConstructFromConstRValue(ref);
-  EXPECT_EQ(17, (*ref)());
-
-  // It shouldn't be possible to construct from `FunctionRef` objects with
-  // differing signatures, even if they are compatible with `int()`.
-  static_assert(!std::constructible_from<Ref, FunctionRef<void()>>);
-  static_assert(!std::constructible_from<Ref, FunctionRef<int(int)>>);
-  static_assert(!std::constructible_from<Ref, FunctionRef<int64_t()>>);
-
-  // Check again with various qualifiers.
-  static_assert(!std::constructible_from<Ref, const FunctionRef<void()>>);
-  static_assert(!std::constructible_from<Ref, FunctionRef<void()>&>);
-  static_assert(!std::constructible_from<Ref, FunctionRef<void()>&&>);
-  static_assert(!std::constructible_from<Ref, const FunctionRef<void()>&>);
-  static_assert(!std::constructible_from<Ref, const FunctionRef<void()>&&>);
-}
-
 // `FunctionRef` allows functors with convertible return types to be adapted.
 TEST(FunctionRef, ConvertibleReturnTypes) {
   {
@@ -200,21 +142,4 @@ TEST(FunctionRef, ConstructionFromInexactMatches) {
                                          decltype(&functor)>);
 }
 
-TEST(FunctionRef, ConstructionFromAbslFunctionRef) {
-  // It shouldn't be possible to construct a `FunctionRef` from an
-  // `absl::FunctionRef`, whether the signatures are compatible or not.
-  using Ref = FunctionRef<int(int)>;
-  static_assert(!std::is_constructible_v<Ref, absl::FunctionRef<void()>>);
-  static_assert(!std::is_constructible_v<Ref, absl::FunctionRef<void(int)>>);
-  static_assert(!std::is_constructible_v<Ref, absl::FunctionRef<int(int)>>);
-
-  // Check again with various qualifiers.
-  using AbslRef = absl::FunctionRef<int(int)>;
-  static_assert(!std::is_constructible_v<Ref, const AbslRef>);
-  static_assert(!std::is_constructible_v<Ref, AbslRef&>);
-  static_assert(!std::is_constructible_v<Ref, AbslRef&&>);
-  static_assert(!std::is_constructible_v<Ref, const AbslRef&>);
-  static_assert(!std::is_constructible_v<Ref, const AbslRef&&>);
-}
-
 }  // namespace base