Fix data race in RenderThreadImplBrowserTest

content/renderer/render_thread_impl_browsertest.cc

 // Copyright 2013 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 "content/renderer/render_thread_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 109 matching lines @@
  public:
   RenderThreadImplForTest(
       const InProcessChildThreadParams& params,
       std::unique_ptr<blink::scheduler::RendererScheduler> scheduler,
       scoped_refptr<base::SingleThreadTaskRunner>& test_task_counter)
       : RenderThreadImpl(params, std::move(scheduler), test_task_counter) {}
 
   ~RenderThreadImplForTest() override {}
 };
 
-class DummyListener : public IPC::Listener {
- public:
-  ~DummyListener() override {}
-
-  bool OnMessageReceived(const IPC::Message& message) override { return true; }
-};
-
 #if defined(COMPILER_MSVC)
 #pragma warning(pop)
 #endif
 
 void QuitTask(base::MessageLoop* message_loop) {
   message_loop->QuitWhenIdle();
 }
 
 class QuitOnTestMsgFilter : public IPC::MessageFilter {
  public:
@@ skipping 27 matching lines @@
     // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler
     // redirection experiment concludes https://crbug.com/622400.
     base::SequencedWorkerPool::DisableForProcessForTesting();
 
     content_renderer_client_.reset(new ContentRendererClient());
     SetRendererClientForTesting(content_renderer_client_.get());
 
     browser_threads_.reset(
         new TestBrowserThreadBundle(TestBrowserThreadBundle::IO_MAINLOOP));
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
+        base::ThreadTaskRunnerHandle::Get();
 
     InitializeMojo();
     ipc_support_.reset(new mojo::edk::test::ScopedIPCSupport(io_task_runner));
     shell_context_.reset(new TestServiceManagerContext);
     child_connection_.reset(new ChildConnection(
         mojom::kRendererServiceName, "test", mojo::edk::GenerateRandomToken(),
         ServiceManagerConnection::GetForProcess()->GetConnector(),
         io_task_runner));
 
     mojo::MessagePipe pipe;
     IPC::mojom::ChannelBootstrapPtr channel_bootstrap;
     child_connection_->GetRemoteInterfaces()->GetInterface(&channel_bootstrap);
 
-    dummy_listener_.reset(new DummyListener);
     channel_ = IPC::ChannelProxy::Create(
         IPC::ChannelMojo::CreateServerFactory(
             channel_bootstrap.PassInterface().PassHandle(), io_task_runner),
-        dummy_listener_.get(), io_task_runner);
+        nullptr, io_task_runner);
 
     mock_process_.reset(new MockRenderProcess);
     test_task_counter_ = make_scoped_refptr(new TestTaskCounter());
 
     // RenderThreadImpl expects the browser to pass these flags.
     base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
     base::CommandLine::StringVector old_argv = cmd->argv();
 
     cmd->AppendSwitchASCII(switches::kNumRasterThreads, "1");
     cmd->AppendSwitchASCII(
@@ skipping 19 matching lines @@
   IPC::Sender* sender() { return channel_.get(); }
 
   scoped_refptr<TestTaskCounter> test_task_counter_;
   TestContentClientInitializer content_client_initializer_;
   std::unique_ptr<ContentRendererClient> content_renderer_client_;
 
   std::unique_ptr<TestBrowserThreadBundle> browser_threads_;
   std::unique_ptr<mojo::edk::test::ScopedIPCSupport> ipc_support_;
   std::unique_ptr<TestServiceManagerContext> shell_context_;
   std::unique_ptr<ChildConnection> child_connection_;
-  std::unique_ptr<DummyListener> dummy_listener_;
   std::unique_ptr<IPC::ChannelProxy> channel_;
 
   std::unique_ptr<MockRenderProcess> mock_process_;
   scoped_refptr<QuitOnTestMsgFilter> test_msg_filter_;
   RenderThreadImplForTest* thread_;  // Owned by mock_process_.
 };
 
 void CheckRenderThreadInputHandlerManager(RenderThreadImpl* thread) {
   ASSERT_TRUE(thread->input_handler_manager());
 }
@@ skipping 129 matching lines @@
                        // These formats are guaranteed to work on all platforms.
                        ::testing::Values(gfx::BufferFormat::R_8,
                                          gfx::BufferFormat::BGR_565,
                                          gfx::BufferFormat::RGBA_4444,
                                          gfx::BufferFormat::RGBA_8888,
                                          gfx::BufferFormat::BGRA_8888,
                                          gfx::BufferFormat::YVU_420)));
 
 }  // namespace
 }  // namespace content