Add FlushForTesting to base::Thread.

base/threading/thread_unittest.cc

 // Copyright (c) 2012 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/threading/thread.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/gtest_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Thread;
 
 typedef PlatformTest ThreadTest;
 
 namespace {
 
@@ skipping 398 matching lines @@
 }
 
 TEST_F(ThreadTest, MultipleWaitUntilThreadStarted) {
   Thread a("MultipleWaitUntilThreadStarted");
   EXPECT_TRUE(a.Start());
   // It's OK to call WaitUntilThreadStarted() multiple times.
   EXPECT_TRUE(a.WaitUntilThreadStarted());
   EXPECT_TRUE(a.WaitUntilThreadStarted());
 }
 
+TEST_F(ThreadTest, FlushForTesting) {
+  Thread a("FlushForTesting");
+
+  // Flushing a non-running thread should be a no-op.
+  a.FlushForTesting();
+
+  ASSERT_TRUE(a.Start());
+
+  // Flushing a thread with no tasks shouldn't block.
+  a.FlushForTesting();
+
+  constexpr base::TimeDelta kSleepPerTestTask =
+      base::TimeDelta::FromMilliseconds(50);
+  constexpr size_t kNumSleepTasks = 5;
+
+  const base::TimeTicks ticks_before_post = base::TimeTicks::Now();
+
+  for (size_t i = 0; i < kNumSleepTasks; ++i) {
+    a.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&base::PlatformThread::Sleep, kSleepPerTestTask));
+  }
+
+  // All tasks should have executed, as reflected by the elapsed time.
+  a.FlushForTesting();
+  EXPECT_GE(base::TimeTicks::Now() - ticks_before_post,
+            kNumSleepTasks * kSleepPerTestTask);
+
+  a.Stop();
+
+  // Flushing a stopped thread should be a no-op.
+  a.FlushForTesting();
+}
+
 namespace {
 
 // A Thread which uses a MessageLoop on the stack. It won't start a real
 // underlying thread (instead its messages can be processed by a RunLoop on the
 // stack).
 class ExternalMessageLoopThread : public Thread {
  public:
   ExternalMessageLoopThread() : Thread("ExternalMessageLoopThread") {}
 
   ~ExternalMessageLoopThread() override { Stop(); }
@@ skipping 25 matching lines @@
 
   a.Stop();
   EXPECT_FALSE(a.message_loop());
   EXPECT_FALSE(a.IsRunning());
 
   // Confirm that running any remaining tasks posted from Stop() goes smoothly
   // (e.g. https://codereview.chromium.org/2135413003/#ps300001 crashed if
   // StopSoon() posted Thread::ThreadQuitHelper() while |run_loop_| was null).
   base::RunLoop().RunUntilIdle();
 }