Make BackgroundFuture properly movable.

Currently moved out `BackgroundFuture` holds an empty thread handle, which is not joinable, and destructor crashes.

PiperOrigin-RevId: 621071166

Author: tomokinat

src/base/thread.h

@@ -47,9 +47,9 @@ namespace mozc {
 // Represents a thread, exposing a subset of `std::thread` APIs.
 //
 // Most notably, threads are undetachable unlike `std::thread`, thus must be
-// `join()`ed before destruction. This means that the `mozc::Thread` instance
-// must be retained even for a long-running one, though which may be until
-// the end of the process.
+// `Join()`ed before destruction if `Joinable()`. This means that the
+// `mozc::Thread` instance must be retained even for a long-running one, though
+// which may be until the end of the process.
 //
 // The semantics of the present APIs are mostly the same as `std::thread`
 // counterpart of the same (but lowercase) name, except that the behavior of
@@ -77,6 +77,8 @@ class Thread {
   Thread(Thread &&) noexcept = default;
   Thread &operator=(Thread &&) noexcept = default;
 
+  bool Joinable() const noexcept { return thread_.joinable(); }
+
   void Join() { thread_.join(); }
 
  private:
@@ -182,7 +184,9 @@ BackgroundFuture<R>::BackgroundFuture(F &&f, Args &&...args)
 
 template <class R>
 BackgroundFuture<R>::~BackgroundFuture() {
-  thread_.Join();
+  if (thread_.Joinable()) {
+    thread_.Join();
+  }
 }
 
 template <class R>
@@ -229,7 +233,11 @@ BackgroundFuture<void>::BackgroundFuture(F &&f, Args &&...args)
         done.Notify();
       }) {}
 
-inline BackgroundFuture<void>::~BackgroundFuture() { thread_.Join(); }
+inline BackgroundFuture<void>::~BackgroundFuture() {
+  if (thread_.Joinable()) {
+    thread_.Join();
+  }
+}
 
 inline void BackgroundFuture<void>::Wait() const {
   done_->WaitForNotification();

src/base/thread_test.cc

@@ -31,6 +31,7 @@
 
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/synchronization/notification.h"
@@ -93,6 +94,16 @@ TEST(ThreadTest, CopiesThingsAtMostOnce) {
   EXPECT_EQ(c2->load(), 0);
 }
 
+TEST(ThreadTest, Joinable) {
+  Thread default_constructed;
+  EXPECT_FALSE(default_constructed.Joinable());
+
+  Thread real_work([] {});
+  EXPECT_TRUE(real_work.Joinable());
+  real_work.Join();
+  EXPECT_FALSE(real_work.Joinable());
+}
+
 TEST(BackgroundFutureTest, ReturnsComputedValueOnReady) {
   auto future = BackgroundFuture<int>([] {
     absl::SleepFor(absl::Milliseconds(100));
@@ -164,5 +175,14 @@ TEST(BackgroundFutureTest, CopiesThingsAtMostOnce) {
   }
 }
 
+TEST(BackgroundFutureTest, DestructingMovedOutFutureDoesNotCrash) {
+  std::optional<BackgroundFuture<int>> f;
+  {
+    auto g = BackgroundFuture<int>([] { return 42; });
+    f = std::move(g);
+  }
+  EXPECT_EQ(f->Get(), 42);
+}
+
 }  // namespace
 }  // namespace mozc