diff --git a/BUILD.gn b/BUILD.gn
index 443a4ff..af3a690 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -538,6 +538,7 @@
       "call:fake_network_pipe_unittests",
       "p2p:libstunprober_unittests",
       "p2p:rtc_p2p_unittests",
+      "rtc_base:function_unittest",
       "rtc_base:rtc_base_approved_unittests",
       "rtc_base:rtc_base_unittests",
       "rtc_base:rtc_json_unittests",
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index 1d4a28d..105bbc3 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -1158,6 +1158,15 @@
     ]
   }
 
+  rtc_library("function_unittest") {
+    testonly = true
+    sources = [ "function_unittest.cc" ]
+    deps = [
+      ":function",
+      "../test:test_support",
+    ]
+  }
+
   rtc_library("rtc_base_nonparallel_tests") {
     testonly = true
 
diff --git a/rtc_base/function.h b/rtc_base/function.h
index 67fcd59..cbc5f7d 100644
--- a/rtc_base/function.h
+++ b/rtc_base/function.h
@@ -102,9 +102,10 @@
     } else {
       // The callable is either nontrivial or too large, so we can't keep it
       // in the inline storage; use the heap instead.
+      webrtc_function_impl::VoidUnion vu;
+      vu.void_ptr = new F_deref(std::forward<F>(f));
       return UntypedFunction(
-          webrtc_function_impl::VoidUnion{.void_ptr =
-                                              new F_deref(std::forward<F>(f))},
+          vu,
           reinterpret_cast<webrtc_function_impl::FunVoid*>(
               webrtc_function_impl::CallHelpers<
                   Signature>::template CallVoidPtr<F_deref>),
@@ -123,8 +124,10 @@
   // the result is an empty UntypedFunction.
   template <typename Signature>
   static UntypedFunction Create(Signature* f) {
+    webrtc_function_impl::VoidUnion vu;
+    vu.fun_ptr = reinterpret_cast<webrtc_function_impl::FunVoid*>(f);
     return UntypedFunction(
-        reinterpret_cast<webrtc_function_impl::FunVoid*>(f),
+        vu,
         f ? reinterpret_cast<webrtc_function_impl::FunVoid*>(
                 webrtc_function_impl::CallHelpers<Signature>::CallFunPtr)
           : nullptr,
@@ -134,6 +137,18 @@
   // Default constructor. Creates an empty UntypedFunction.
   UntypedFunction() : call_(nullptr), delete_(nullptr) {}
 
+  // Nullptr constructor and assignment. Creates an empty UntypedFunction.
+  UntypedFunction(std::nullptr_t)  // NOLINT(runtime/explicit)
+      : call_(nullptr), delete_(nullptr) {}
+  UntypedFunction& operator=(std::nullptr_t) {
+    call_ = nullptr;
+    if (delete_) {
+      delete_(&f_);
+      delete_ = nullptr;
+    }
+    return *this;
+  }
+
   // Not copyable.
   UntypedFunction(const UntypedFunction&) = delete;
   UntypedFunction& operator=(const UntypedFunction&) = delete;
@@ -144,6 +159,9 @@
     other.delete_ = nullptr;
   }
   UntypedFunction& operator=(UntypedFunction&& other) {
+    if (delete_) {
+      delete_(&f_);
+    }
     f_ = other.f_;
     call_ = other.call_;
     delete_ = other.delete_;
@@ -169,7 +187,7 @@
 
   template <typename Signature, typename... ArgT>
   typename webrtc_function_impl::CallHelpers<Signature>::return_type Call(
-      ArgT... args) {
+      ArgT&&... args) {
     return webrtc_function_impl::CallHelpers<Signature>::DoCall(
         call_, &f_, std::forward<ArgT>(args)...);
   }
diff --git a/rtc_base/function_unittest.cc b/rtc_base/function_unittest.cc
new file mode 100644
index 0000000..7a3d658
--- /dev/null
+++ b/rtc_base/function_unittest.cc
@@ -0,0 +1,307 @@
+/*
+ *  Copyright (c) 2020 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "rtc_base/function.h"
+
+#include <memory>
+#include <vector>
+
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+namespace {
+
+using ::testing::Pointee;
+
+TEST(UntypedFunction, Empty1) {
+  UntypedFunction uf;
+  EXPECT_FALSE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+}
+
+TEST(UntypedFunction, Empty2) {
+  UntypedFunction uf = nullptr;
+  EXPECT_FALSE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+}
+
+TEST(UntypedFunction, Empty3) {
+  UntypedFunction uf = UntypedFunction::Create<int(int)>(nullptr);
+  EXPECT_FALSE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+}
+
+TEST(UntypedFunction, CallTrivialWithInt) {
+  auto uf = UntypedFunction::Create<int(int)>([](int x) { return x + 5; });
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int(int)>(17), 22);
+}
+
+TEST(UntypedFunction, CallTrivialWithPointer) {
+  auto uf = UntypedFunction::Create<int(int*)>([](int* x) { return *x; });
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  int x = 12;
+  EXPECT_EQ(uf.Call<int(int*)>(&x), 12);
+}
+
+TEST(UntypedFunction, CallTrivialWithReference) {
+  auto uf = UntypedFunction::Create<void(int&)>([](int& x) { x = 3; });
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  int x = 12;
+  uf.Call<void(int&)>(x);
+  EXPECT_EQ(x, 3);
+}
+
+TEST(UntypedFunction, CallTrivialWithRvalueReference) {
+  auto uf = UntypedFunction::Create<int(int&&)>([](int&& x) { return x - 2; });
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int(int&&)>(34), 32);
+}
+
+TEST(UntypedFunction, CallNontrivialWithInt) {
+  std::vector<int> list;
+  auto uf = UntypedFunction::Create<int(int)>([list](int x) mutable {
+    list.push_back(x);
+    return list.size();
+  });
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int(int)>(17), 1);
+  EXPECT_EQ(uf.Call<int(int)>(17), 2);
+}
+
+TEST(UntypedFunction, CallNontrivialWithPointer) {
+  std::vector<int> list;
+  auto uf = UntypedFunction::Create<int*(int*)>([list](int* x) mutable {
+    list.push_back(*x);
+    return list.data();
+  });
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  int x = 12;
+  EXPECT_THAT(uf.Call<int*(int*)>(&x), Pointee(12));
+}
+
+TEST(UntypedFunction, CallNontrivialWithReference) {
+  std::vector<int> list = {34, 35, 36};
+  auto uf =
+      UntypedFunction::Create<void(int&)>([list](int& x) { x = list[1]; });
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  int x = 12;
+  uf.Call<void(int&)>(x);
+  EXPECT_EQ(x, 35);
+}
+
+TEST(UntypedFunction, CallNontrivialWithRvalueReference) {
+  std::vector<int> list;
+  auto uf = UntypedFunction::Create<int(int&&)>([list](int&& x) mutable {
+    list.push_back(x);
+    return list.size();
+  });
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int(int&&)>(34), 1);
+  EXPECT_EQ(uf.Call<int(int&&)>(34), 2);
+}
+
+int AddFive(int x) {
+  return x + 5;
+}
+int DereferencePointer(int* x) {
+  return *x;
+}
+void AssignThree(int& x) {
+  x = 3;
+}
+int SubtractTwo(int&& x) {
+  return x - 2;
+}
+
+TEST(UntypedFunction, CallFunctionPointerWithInt) {
+  auto uf = UntypedFunction::Create<int(int)>(AddFive);
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int(int)>(17), 22);
+}
+
+TEST(UntypedFunction, CallFunctionPointerWithPointer) {
+  auto uf = UntypedFunction::Create<int(int*)>(DereferencePointer);
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  int x = 12;
+  EXPECT_EQ(uf.Call<int(int*)>(&x), 12);
+}
+
+TEST(UntypedFunction, CallFunctionPointerWithReference) {
+  auto uf = UntypedFunction::Create<void(int&)>(AssignThree);
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  int x = 12;
+  uf.Call<void(int&)>(x);
+  EXPECT_EQ(x, 3);
+}
+
+TEST(UntypedFunction, CallFunctionPointerWithRvalueReference) {
+  auto uf = UntypedFunction::Create<int(int&&)>(SubtractTwo);
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int(int&&)>(34), 32);
+}
+
+TEST(UntypedFunction, CallTrivialWithNoArgs) {
+  int arr[] = {1, 2, 3};
+  auto uf = UntypedFunction::Create<int()>([arr] { return arr[1]; });
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int()>(), 2);
+}
+
+TEST(UntypedFunction, CallLargeTrivialWithNoArgs) {
+  int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
+  auto uf = UntypedFunction::Create<int()>([arr] { return arr[4]; });
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int()>(), 5);
+}
+
+TEST(UntypedFunction, MoveonlyReturnValue) {
+  auto uf = UntypedFunction::Create<std::unique_ptr<int>()>(
+      [] { return std::make_unique<int>(567); });
+  EXPECT_THAT(uf.Call<std::unique_ptr<int>()>(), Pointee(567));
+}
+
+TEST(UntypedFunction, MoveonlyArgument) {
+  auto uf = UntypedFunction::Create<int(std::unique_ptr<int>)>(
+      [](std::unique_ptr<int> x) { return *x + 19; });
+  EXPECT_EQ(uf.Call<int(std::unique_ptr<int>)>(std::make_unique<int>(40)), 59);
+}
+
+TEST(UntypedFunction, MoveOnlyCallable) {
+  auto uf = UntypedFunction::Create<int()>(
+      [x = std::make_unique<int>(17)] { return ++*x; });
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int()>(), 18);
+  EXPECT_EQ(uf.Call<int()>(), 19);
+  UntypedFunction uf2 = std::move(uf);
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_FALSE(uf2.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int()>(), 20);
+  EXPECT_EQ(uf.Call<int()>(), 21);
+}
+
+class Destroyer {
+ public:
+  explicit Destroyer(int& destroy_count) : destroy_count_(&destroy_count) {}
+  ~Destroyer() { ++*destroy_count_; }
+  int operator()() { return 72; }
+  int* destroy_count_;
+};
+
+TEST(UntypedFunction, CallableIsDestroyed) {
+  int destroy_count = 0;
+  {
+    auto uf = UntypedFunction::Create<int()>(Destroyer(destroy_count));
+    // Destruction count is 1 here, because the temporary we created above was
+    // destroyed.
+    EXPECT_EQ(destroy_count, 1);
+    {
+      auto uf2 = std::move(uf);
+      EXPECT_EQ(destroy_count, 1);
+    }
+    // `uf2` was destroyed.
+    EXPECT_EQ(destroy_count, 2);
+  }
+  // `uf` was destroyed, but it didn't contain a Destroyer since we moved it to
+  // `uf2` above.
+  EXPECT_EQ(destroy_count, 2);
+}
+
+TEST(UntypedFunction, MoveAssign) {
+  int destroy_count = 0;
+  auto uf = UntypedFunction::Create<int()>(Destroyer(destroy_count));
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  // Destruction count is 1 here, because the temporary we created above was
+  // destroyed.
+  EXPECT_EQ(destroy_count, 1);
+  UntypedFunction uf2 = nullptr;
+  EXPECT_FALSE(uf2);
+  EXPECT_TRUE(uf2.IsTriviallyDestructible());
+
+  uf2 = std::move(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_TRUE(uf2);
+  EXPECT_FALSE(uf2.IsTriviallyDestructible());
+  EXPECT_EQ(destroy_count, 1);  // The callable was not destroyed.
+  EXPECT_EQ(uf2.Call<int()>(), 72);
+
+  UntypedFunction uf3 = nullptr;
+  uf2 = std::move(uf3);
+  EXPECT_FALSE(uf2);
+  EXPECT_TRUE(uf2.IsTriviallyDestructible());
+  EXPECT_EQ(destroy_count, 2);  // The callable was destroyed by the assignment.
+}
+
+TEST(UntypedFunction, NullptrAssign) {
+  int destroy_count = 0;
+  auto uf = UntypedFunction::Create<int()>(Destroyer(destroy_count));
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  // Destruction count is 1 here, because the temporary we created above was
+  // destroyed.
+  EXPECT_EQ(destroy_count, 1);
+
+  uf = nullptr;
+  EXPECT_FALSE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_EQ(destroy_count, 2);  // The callable was destroyed by the assignment.
+}
+
+TEST(UntypedFunction, Swap) {
+  int x = 13;
+  auto uf = UntypedFunction::Create<int()>([x]() mutable { return ++x; });
+  EXPECT_TRUE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  auto y = std::make_unique<int>(113);
+  auto uf2 =
+      UntypedFunction::Create<int()>([y = std::move(y)] { return ++*y; });
+  EXPECT_TRUE(uf2);
+  EXPECT_FALSE(uf2.IsTriviallyDestructible());
+  UntypedFunction uf3 = nullptr;
+  EXPECT_FALSE(uf3);
+  EXPECT_TRUE(uf3.IsTriviallyDestructible());
+
+  EXPECT_EQ(uf.Call<int()>(), 14);
+  swap(uf, uf2);
+  EXPECT_TRUE(uf);
+  EXPECT_FALSE(uf.IsTriviallyDestructible());
+  EXPECT_TRUE(uf2);
+  EXPECT_TRUE(uf2.IsTriviallyDestructible());
+  EXPECT_EQ(uf.Call<int()>(), 114);
+  EXPECT_EQ(uf2.Call<int()>(), 15);
+
+  swap(uf, uf3);
+  EXPECT_FALSE(uf);
+  EXPECT_TRUE(uf.IsTriviallyDestructible());
+  EXPECT_TRUE(uf3);
+  EXPECT_FALSE(uf3.IsTriviallyDestructible());
+  EXPECT_EQ(uf3.Call<int()>(), 115);
+}
+
+}  // namespace
+}  // namespace webrtc