Do not block in SimpleThread::Start().

base/win/wait_chain_unittest.cc

 // Copyright 2016 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 "base/win/wait_chain.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 91 matching lines @@
   void WaitForMutexAcquired() {
     EXPECT_EQ(WAIT_OBJECT_0,
               ::WaitForSingleObject(mutex_acquired_event_.Get(), INFINITE));
   }
 
   // Signal the thread to acquire the second mutex.
   void SignalToAcquireMutex() { EXPECT_TRUE(::SetEvent(wait_event_.Get())); }
 
   // Terminates the thread.
   bool Terminate() {
-    ScopedHandle thread_handle(::OpenThread(THREAD_TERMINATE, FALSE, tid()));
+    ScopedHandle thread_handle(::OpenThread(THREAD_TERMINATE, FALSE, GetTid()));

[gab, 2017/02/06 20:29:11]

Need to allow wait on these or is it allowed by default in tests?

[fdoray, 2017/02/06 20:46:48]

Allowed by default. Disallowed on UI and IO threads + a few other cases
https://cs.chromium.org/search/?q=disallowwaiting&type=cs

     return ::TerminateThread(thread_handle.Get(), 0);
   }
 
  private:
   ScopedHandle wait_event_;
   ScopedHandle mutex_acquired_event_;
 
   // The 2 mutex to acquire.
   HANDLE mutex_1_;
   HANDLE mutex_2_;
@@ skipping 129 matching lines @@
   Sleep(10);
 
   // Create a few waiting threads to get a longer wait chain.
   std::unique_ptr<SingleTaskThread> waiting_thread_1 =
       CreateJoiningThread(deadlock_thread_1.get());
   std::unique_ptr<SingleTaskThread> waiting_thread_2 =
       CreateJoiningThread(waiting_thread_1.get());
 
   WaitChainNodeVector wait_chain;
   bool is_deadlock;
-  ASSERT_TRUE(GetThreadWaitChain(waiting_thread_2->tid(), &wait_chain,
+  ASSERT_TRUE(GetThreadWaitChain(waiting_thread_2->GetTid(), &wait_chain,
                                  &is_deadlock, nullptr, nullptr));
 
   EXPECT_EQ(9U, wait_chain.size());
   EXPECT_TRUE(is_deadlock);
   EXPECT_TRUE(WaitChainStructureIsCorrect(wait_chain));
   EXPECT_FALSE(WaitChainIsCrossProcess(wait_chain));
 
   ASSERT_TRUE(deadlock_thread_1->Terminate());
 
   // The SimpleThread API expect Join() to be called before destruction.
@@ skipping 18 matching lines @@
   // Create a few waiting threads to get a longer wait chain.
   std::unique_ptr<SingleTaskThread> waiting_thread_1 =
       CreateWaitingThread(mutex.Get());
   std::unique_ptr<SingleTaskThread> waiting_thread_2 =
       CreateJoiningThread(waiting_thread_1.get());
   std::unique_ptr<SingleTaskThread> waiting_thread_3 =
       CreateJoiningThread(waiting_thread_2.get());
 
   WaitChainNodeVector wait_chain;
   bool is_deadlock;
-  ASSERT_TRUE(GetThreadWaitChain(waiting_thread_3->tid(), &wait_chain,
+  ASSERT_TRUE(GetThreadWaitChain(waiting_thread_3->GetTid(), &wait_chain,
                                  &is_deadlock, nullptr, nullptr));
 
   EXPECT_EQ(7U, wait_chain.size());
   EXPECT_FALSE(is_deadlock);
   EXPECT_TRUE(WaitChainStructureIsCorrect(wait_chain));
   EXPECT_TRUE(WaitChainIsCrossProcess(wait_chain));
 
   // Unblock child process and wait for it to terminate.
   ASSERT_TRUE(::SetEvent(sync_event.Get()));
   ASSERT_TRUE(child_process.WaitForExit(nullptr));
 
   // The SimpleThread API expect Join() to be called before destruction.
   waiting_thread_3->Join();
 }
 
 }  // namespace win
 }  // namespace base