test: remove the manual declarations of TestThread and figure it out from the platform.

source/common/common/thread.cc

@@ -28,7 +28,16 @@ struct ThreadIds {
     // and are cleared when being released. All possible thread orderings
     // result in the correct result even without a lock.
     std::thread::id id = std::this_thread::get_id();
-    return main_thread_id_ == id || test_thread_id_ == id;
+    return main_thread_id_ == id ||
+    // https://stackoverflow.com/questions/4867839/how-can-i-tell-if-pthread-self-is-the-main-first-thread-in-the-process
+#ifdef __linux__
+           getpid() == syscall(SYS_gettid)
+#elif defined(__APPLE__)
+           pthread_main_np() != 0
+#else
+           true
+#endif
+        ;
   }
 
   bool isMainThreadActive() const {
@@ -53,20 +62,6 @@ struct ThreadIds {
     }
   }
 
-  // Call this when the TestThread exits. Nested semantics are supported, so
-  // that if multiple TestThread instances are declared, we unwind them
-  // properly.
-  void releaseTestThread() {
-    absl::MutexLock lock(&mutex_);
-    ASSERT(test_thread_use_count_ > 0);
-    ASSERT(std::this_thread::get_id() == test_thread_id_);
-    if (--test_thread_use_count_ == 0) {
-      // Clearing the thread ID when its use-count goes to zero allows us
-      // to read the atomic without taking a lock.
-      test_thread_id_ = std::thread::id{};
-    }
-  }
-
   // Declares current thread as the main one, or verifies that the current
   // thread matches any previous declarations.
   void registerMainThread() {
@@ -78,27 +73,14 @@ struct ThreadIds {
     }
   }
 
-  // Declares current thread as the test thread, or verifies that the current
-  // thread matches any previous declarations.
-  void registerTestThread() {
-    absl::MutexLock lock(&mutex_);
-    if (++test_thread_use_count_ > 1) {
-      ASSERT(std::this_thread::get_id() == test_thread_id_);
-    } else {
-      test_thread_id_ = std::this_thread::get_id();
-    }
-  }
-
 private:
   // The atomic thread IDs can be read without a mutex, but they are written
   // under a mutex so that they are consistent with their use_counts. this
   // avoids the possibility of two threads racing to claim being the main/test
   // thread.
   std::atomic<std::thread::id> main_thread_id_;
-  std::atomic<std::thread::id> test_thread_id_;
 
   int32_t main_thread_use_count_ GUARDED_BY(mutex_) = 0;
-  int32_t test_thread_use_count_ GUARDED_BY(mutex_) = 0;
   mutable absl::Mutex mutex_;
 };
 
@@ -108,10 +90,6 @@ bool MainThread::isMainOrTestThread() { return ThreadIds::get().inMainOrTestThre
 
 bool MainThread::isMainThreadActive() { return ThreadIds::get().isMainThreadActive(); }
 
-TestThread::TestThread() { ThreadIds::get().registerTestThread(); }
-
-TestThread::~TestThread() { ThreadIds::get().releaseTestThread(); }
-
 MainThread::MainThread() { ThreadIds::get().registerMainThread(); }
 
 MainThread::~MainThread() { ThreadIds::get().releaseMainThread(); }

source/common/common/thread.h

@@ -168,17 +168,12 @@ class AtomicPtr : private AtomicPtrArray<T, 1, alloc_mode> {
   T* get(const MakeObject& make_object) { return BaseClass::get(0, make_object); }
 };
 
-// RAII object to declare the TestThread. This should be declared in main() or
-// equivalent for any test binaries.
+// Deprecated RAII object to declare the TestThread. This is no longer needed as
+// we figure this out automatically from the platform.
 //
-// Generally we expect TestThread to be instantiated only once on main() for
-// each test binary, though nested instantiations are allowed as long as the
-// thread ID does not change.
-class TestThread {
-public:
-  TestThread();
-  ~TestThread();
-};
+// TODO(jmarantz): Remove this declaration after Nov 15, 2021 to allow
+// references from other repositories to be cleaned up.
+struct TestThread {};
 
 // RAII object to declare the MainThread. This should be declared in the thread
 // function or equivalent.

test/benchmark/main.cc

@@ -43,7 +43,6 @@ int main(int argc, char** argv) {
   }
 
   TestEnvironment::initializeTestMain(argv[0]);
-  Thread::TestThread test_thread;
 
   // Suppressing non-error messages in benchmark tests. This hides warning
   // messages that appear when using a runtime feature when there isn't an initialized

test/fuzz/fuzz_runner.cc

@@ -31,8 +31,6 @@ void Runner::setupEnvironment(int argc, char** argv, spdlog::level::level_enum d
   // state.
   ProcessWide process_wide;
   TestEnvironment::initializeOptions(argc, argv);
-  static auto* test_thread = new Envoy::Thread::TestThread;
-  UNREFERENCED_PARAMETER(test_thread);
 
   const auto environment_log_level = TestEnvironment::getOptions().logLevel();
   // We only override the default log level if it looks like we're debugging;

test/integration/base_integration_test.h

@@ -364,8 +364,6 @@ class BaseIntegrationTest : protected Logger::Loggable<Logger::Id::testing> {
 
   std::unique_ptr<Stats::Scope> upstream_stats_store_;
 
-  Thread::TestThread test_thread_;
-
   // Make sure the test server will be torn down after any fake client.
   // The test server owns the runtime, which is often accessed by client and
   // fake upstream codecs and must outlast them.

test/test_runner.cc

@@ -73,8 +73,6 @@ class RuntimeManagingListener : public ::testing::EmptyTestEventListener {
 } // namespace
 
 int TestRunner::RunTests(int argc, char** argv) {
-  Thread::TestThread test_thread;
-
   ::testing::InitGoogleMock(&argc, argv);
   // We hold on to process_wide to provide RAII cleanup of process-wide
   // state.

test/tools/router_check/router_check.cc

@@ -9,7 +9,6 @@
 #include "test/tools/router_check/router.h"
 
 int main(int argc, char* argv[]) {
-  Envoy::Thread::TestThread test_thread;
   Envoy::Options options(argc, argv);
 
   const bool enforce_coverage = options.failUnder() != 0.0;