Oilpan: Replace Main/WorkerThreadMutex with one ActiveThreadMutex

TSAN reported lock-order-inversion because we were using two mutexes. Simplify the code to use just one.

Bug: 915200
Change-Id: I5dbda4ca21cd4f5fa95ecb1c9b51922262798169
Reviewed-on: https://chromium-review.googlesource.com/c/1384384
Commit-Queue: Keishi Hattori <keishi@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#618754}

third_party/blink/renderer/platform/heap/BUILD.gn

@@ -120,6 +120,7 @@ jumbo_source_set("blink_heap_unittests_sources") {
     "heap_test.cc",
     "heap_test_utilities.cc",
     "heap_test_utilities.h",
+    "heap_thread_test.cc",
     "heap_traits_test.cc",
     "incremental_marking_test.cc",
     "name_trait_test.cc",

third_party/blink/renderer/platform/heap/heap_thread_test.cc

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/renderer/platform/cross_thread_functional.h"
+#include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/heap/heap_test_utilities.h"
+#include "third_party/blink/renderer/platform/heap/thread_state.h"
+#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
+#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
+
+namespace blink {
+namespace heap_thread_test {
+
+static Mutex& ActiveThreadMutex() {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, active_thread_mutex, ());
+  return active_thread_mutex;
+}
+
+static ThreadCondition& ActiveThreadCondition() {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadCondition, active_thread_condition,
+                                  (ActiveThreadMutex()));
+  return active_thread_condition;
+}
+
+enum ActiveThreadState {
+  kNoThreadActive,
+  kMainThreadActive,
+  kWorkerThreadActive,
+};
+
+static ActiveThreadState& ActiveThread() {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ActiveThreadState, active_thread,
+                                  (kNoThreadActive));
+  return active_thread;
+}
+
+static void WakeMainThread() {
+  ActiveThread() = kMainThreadActive;
+  ActiveThreadCondition().Signal();
+}
+
+static void WakeWorkerThread() {
+  ActiveThread() = kWorkerThreadActive;
+  ActiveThreadCondition().Signal();
+}
+
+static void ParkMainThread() {
+  while (ActiveThread() != kMainThreadActive) {
+    ActiveThreadCondition().Wait();
+  }
+}
+
+static void ParkWorkerThread() {
+  while (ActiveThread() != kWorkerThreadActive) {
+    ActiveThreadCondition().Wait();
+  }
+}
+
+class Object : public GarbageCollected<Object> {
+ public:
+  Object() {}
+  ~Object() {}
+  void Trace(blink::Visitor* visitor) {}
+};
+
+class AlternatingThreadTester {
+ public:
+  void Test() {
+    MutexLocker locker(ActiveThreadMutex());
+    ActiveThread() = kMainThreadActive;
+
+    std::unique_ptr<Thread> worker_thread = Platform::Current()->CreateThread(
+        ThreadCreationParams(WebThreadType::kTestThread)
+            .SetThreadNameForTest("Test Worker Thread"));
+    PostCrossThreadTask(
+        *worker_thread->GetTaskRunner(), FROM_HERE,
+        CrossThreadBind(&AlternatingThreadTester::StartWorkerThread,
+                        CrossThreadUnretained(this)));
+
+    MainThreadMain();
+  }
+
+  void SwitchToWorkerThread() {
+    WakeWorkerThread();
+    ParkMainThread();
+  }
+
+  void SwitchToMainThread() {
+    WakeMainThread();
+    ParkWorkerThread();
+  }
+
+ protected:
+  // Override with code you want to execute on the main thread.
+  virtual void MainThreadMain() = 0;
+  // Override with code you want to execute on the worker thread. At the end,
+  // the ThreadState is detached and we switch back to the main thread
+  // automatically.
+  virtual void WorkerThreadMain() = 0;
+
+ private:
+  void StartWorkerThread() {
+    ThreadState::AttachCurrentThread();
+
+    MutexLocker locker(ActiveThreadMutex());
+
+    WorkerThreadMain();
+
+    ThreadState::DetachCurrentThread();
+    WakeMainThread();
+  }
+};
+
+class MemberSameThreadCheckTester : public AlternatingThreadTester {
+ private:
+  void MainThreadMain() override { SwitchToWorkerThread(); }
+
+  void WorkerThreadMain() override {
+    // Setting an object created on the worker thread to a Member allocated on
+    // the main thread is not allowed.
+    object_ = MakeGarbageCollected<Object>();
+  }
+
+  Member<Object> object_;
+};
+
+#if DCHECK_IS_ON()
+// TODO(keishi) This test is flaky on mac_chromium_rel_ng bot.
+// crbug.com/709069
+#if !defined(OS_MACOSX)
+TEST(HeapDeathTest, MemberSameThreadCheck) {
+  EXPECT_DEATH(MemberSameThreadCheckTester().Test(), "");
+}
+#endif
+#endif
+
+class PersistentSameThreadCheckTester : public AlternatingThreadTester {
+ private:
+  void MainThreadMain() override { SwitchToWorkerThread(); }
+
+  void WorkerThreadMain() override {
+    // Setting an object created on the worker thread to a Persistent allocated
+    // on the main thread is not allowed.
+    object_ = MakeGarbageCollected<Object>();
+  }
+
+  Persistent<Object> object_;
+};
+
+#if DCHECK_IS_ON()
+// TODO(keishi) This test is flaky on mac_chromium_rel_ng bot.
+// crbug.com/709069
+#if !defined(OS_MACOSX)
+TEST(HeapDeathTest, PersistentSameThreadCheck) {
+  EXPECT_DEATH(PersistentSameThreadCheckTester().Test(), "");
+}
+#endif
+#endif
+
+class MarkingSameThreadCheckTester : public AlternatingThreadTester {
+ private:
+  class MainThreadObject : public GarbageCollectedFinalized<MainThreadObject> {
+   public:
+    void Trace(blink::Visitor* visitor) { visitor->Trace(set_); }
+    void AddToSet(Object* object) { set_.insert(42, object); }
+
+   private:
+    HeapHashMap<int, Member<Object>> set_;
+  };
+
+  void MainThreadMain() override {
+    main_thread_object_ = MakeGarbageCollected<MainThreadObject>();
+
+    SwitchToWorkerThread();
+
+    // This will try to mark MainThreadObject when it tries to mark Object
+    // it should crash.
+    PreciselyCollectGarbage();
+  }
+
+  void WorkerThreadMain() override {
+    // Adding a reference to an object created on the worker thread to a
+    // HeapHashMap created on the main thread is not allowed.
+    main_thread_object_->AddToSet(MakeGarbageCollected<Object>());
+  }
+
+  CrossThreadPersistent<MainThreadObject> main_thread_object_;
+};
+
+#if DCHECK_IS_ON()
+// TODO(keishi) This test is flaky on mac_chromium_rel_ng bot.
+// crbug.com/709069
+#if !defined(OS_MACOSX)
+TEST(HeapDeathTest, MarkingSameThreadCheck) {
+  // This will crash during marking, at the DCHECK in Visitor::markHeader() or
+  // earlier.
+  EXPECT_DEATH(MarkingSameThreadCheckTester().Test(), "");
+}
+#endif
+#endif
+
+class DestructorLockingObject
+    : public GarbageCollectedFinalized<DestructorLockingObject> {
+ public:
+  static DestructorLockingObject* Create() {
+    return MakeGarbageCollected<DestructorLockingObject>();
+  }
+
+  DestructorLockingObject() = default;
+  virtual ~DestructorLockingObject() { ++destructor_calls_; }
+
+  static int destructor_calls_;
+  void Trace(blink::Visitor* visitor) {}
+};
+
+int DestructorLockingObject::destructor_calls_ = 0;
+
+class CrossThreadWeakPersistentTester : public AlternatingThreadTester {
+ private:
+  void MainThreadMain() override {
+    // Create an object in the worker thread, have a CrossThreadWeakPersistent
+    // pointing to it on the main thread, run a GC in the worker thread, and see
+    // if the CrossThreadWeakPersistent is cleared.
+
+    DestructorLockingObject::destructor_calls_ = 0;
+
+    // Step 1: Initiate a worker thread, and wait for |Object| to get allocated
+    // on the worker thread.
+    SwitchToWorkerThread();
+
+    // Step 3: Set up a CrossThreadWeakPersistent.
+    ASSERT_TRUE(object_);
+    EXPECT_EQ(0, DestructorLockingObject::destructor_calls_);
+
+    // Pretend we have no pointers on stack during the step 4.
+    SwitchToWorkerThread();
+
+    // Step 5: Make sure the weak persistent is cleared.
+    EXPECT_FALSE(object_.Get());
+    EXPECT_EQ(1, DestructorLockingObject::destructor_calls_);
+
+    SwitchToWorkerThread();
+  }
+
+  void WorkerThreadMain() override {
+    // Step 2: Create an object and store the pointer.
+    object_ = DestructorLockingObject::Create();
+    SwitchToMainThread();
+
+    // Step 4: Run a GC.
+    ThreadState::Current()->CollectGarbage(
+        BlinkGC::kNoHeapPointersOnStack, BlinkGC::kAtomicMarking,
+        BlinkGC::kEagerSweeping, BlinkGC::GCReason::kForcedGC);
+    SwitchToMainThread();
+  }
+
+  CrossThreadWeakPersistent<DestructorLockingObject> object_;
+};
+
+TEST(HeapThreadTest, CrossThreadWeakPersistent) {
+  CrossThreadWeakPersistentTester().Test();
+}
+
+}  // namespace heap_thread_test
+}  // namespace blink