Fix DirectCompositionSurfaceTest.TestMakeCurrent flakiness.

gpu/ipc/service/direct_composition_surface_win_unittest.cc

 // Copyright 2017 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 "gpu/ipc/service/direct_composition_surface_win.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
+#include "base/synchronization/waitable_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/win/hidden_window.h"
 #include "ui/gl/gl_angle_util_win.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/init/gl_factory.h"
 
 namespace gpu {
 namespace {
 
 class TestImageTransportSurfaceDelegate
     : public ImageTransportSurfaceDelegate,
       public base::SupportsWeakPtr<TestImageTransportSurfaceDelegate> {
  public:
   ~TestImageTransportSurfaceDelegate() override {}
 
   // ImageTransportSurfaceDelegate implementation.
   void DidCreateAcceleratedSurfaceChildWindow(
       SurfaceHandle parent_window,
       SurfaceHandle child_window) override {}
   void DidSwapBuffersComplete(SwapBuffersCompleteParams params) override {}
   const gles2::FeatureInfo* GetFeatureInfo() const override { return nullptr; }
   void SetLatencyInfoCallback(const LatencyInfoCallback& callback) override {}
   void UpdateVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval) override {}
   void AddFilter(IPC::MessageFilter* message_filter) override {}
   int32_t GetRouteID() const override { return 0; }
 };
 
+void RunPendingTasks(scoped_refptr<base::TaskRunner> task_runner) {
+  base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                           base::WaitableEvent::InitialState::NOT_SIGNALED);
+  task_runner->PostTask(FROM_HERE,
+                        Bind(&base::WaitableEvent::Signal, Unretained(&done)));
+  done.Wait();
+}
+
 TEST(DirectCompositionSurfaceTest, TestMakeCurrent) {
   if (!gl::QueryDirectCompositionDevice(
           gl::QueryD3D11DeviceObjectFromANGLE())) {
     LOG(WARNING)
         << "GL implementation not using DirectComposition, skipping test.";
     return;
   }
 
   TestImageTransportSurfaceDelegate delegate;
 
@@ skipping 37 matching lines @@
   EXPECT_TRUE(context2->MakeCurrent(surface2.get()));
   EXPECT_TRUE(surface2->Resize(gfx::Size(100, 100), 1.0, true));
   // The previous IDCompositionSurface should be suspended when another
   // surface is being drawn to.
   EXPECT_TRUE(surface2->SetDrawRectangle(gfx::Rect(0, 0, 100, 100)));
   EXPECT_TRUE(context2->IsCurrent(surface2.get()));
 
   // It should be possible to switch back to the previous surface and
   // unsuspend it.
   EXPECT_TRUE(context->MakeCurrent(surface.get()));
+  scoped_refptr<base::TaskRunner> task_runner1 =
+      surface->GetWindowTaskRunnerForTesting();
+  scoped_refptr<base::TaskRunner> task_runner2 =
+      surface2->GetWindowTaskRunnerForTesting();
 
   context2 = nullptr;
   surface2 = nullptr;
   context = nullptr;
   surface = nullptr;
+
+  // Ensure that the ChildWindowWin posts the task to delete the thread to the
+  // main loop before doing RunUntilIdle. Otherwise the child threads could
+  // outlive the main thread.
+  RunPendingTasks(task_runner1);
+  RunPendingTasks(task_runner2);
+
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace gpu