GpuMain: Fix thread_runner() access DCHECK fail

services/ui/gpu/gpu_main.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 "services/ui/gpu/gpu_main.h"
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
@@ skipping 53 matching lines @@
 #elif defined(OS_MACOSX)
   thread_options.message_pump_factory = base::Bind(&CreateMessagePumpMac);
 #else
   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
 #endif
 
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   thread_options.priority = base::ThreadPriority::DISPLAY;
 #endif
   CHECK(gpu_thread_.StartWithOptions(thread_options));
+  gpu_thread_task_runner_ = gpu_thread_.task_runner();
 
   // TODO(sad): We do not need the IO thread once gpu has a separate process. It
   // should be possible to use |main_task_runner_| for doing IO tasks.
   thread_options = base::Thread::Options(base::MessageLoop::TYPE_IO, 0);
   thread_options.priority = base::ThreadPriority::NORMAL;
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   // TODO(reveman): Remove this in favor of setting it explicitly for each type
   // of process.
   thread_options.priority = base::ThreadPriority::DISPLAY;
 #endif
   CHECK(io_thread_.StartWithOptions(thread_options));
 
   // Start the compositor thread.
   compositor_thread_.Start();
+  compositor_thread_task_runner_ = compositor_thread_.task_runner();
 }
 
 GpuMain::~GpuMain() {
   // Unretained() is OK here since the thread/task runner is owned by |this|.
-  compositor_thread_.task_runner()->PostTask(
+  compositor_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::TearDownOnCompositorThread, base::Unretained(this)));
 
   // Block the main thread until the compositor thread terminates which blocks
   // on the gpu thread. The Stop must be initiated from here instead of the gpu
   // thread to avoid deadlock.
   compositor_thread_.Stop();
 
-  gpu_thread_.task_runner()->PostTask(
+  gpu_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::TearDownOnGpuThread, base::Unretained(this)));
   gpu_thread_.Stop();
   io_thread_.Stop();
 }
 
 void GpuMain::OnStart() {
   // |this| will outlive the gpu thread and so it's safe to use
   // base::Unretained here.
-  gpu_thread_.task_runner()->PostTask(
+  gpu_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::InitOnGpuThread, base::Unretained(this),
-                 io_thread_.task_runner(), compositor_thread_.task_runner()));
+                 io_thread_.task_runner(), compositor_thread_task_runner_));
 }
 
 void GpuMain::CreateGpuService(mojom::GpuServiceRequest request,
                                mojom::GpuHostPtr gpu_host,
                                const gpu::GpuPreferences& preferences) {
   // |this| will outlive the gpu thread and so it's safe to use
   // base::Unretained here.
-  gpu_thread_.task_runner()->PostTask(
+  gpu_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::CreateGpuServiceOnGpuThread, base::Unretained(this),
                  base::Passed(std::move(request)),
                  base::Passed(gpu_host.PassInterface()), preferences));
 }
 
 void GpuMain::CreateDisplayCompositor(
     cc::mojom::DisplayCompositorRequest request,
     cc::mojom::DisplayCompositorClientPtr client) {
   if (!gpu_service_) {
@@ skipping 23 matching lines @@
       gpu_init_->gpu_info(), gpu_init_->TakeWatchdogThread(),
       gpu_memory_buffer_factory_.get(), io_runner,
       gpu_init_->gpu_feature_info());
 }
 
 void GpuMain::CreateDisplayCompositorInternal(
     cc::mojom::DisplayCompositorRequest request,
     cc::mojom::DisplayCompositorClientPtrInfo client_info) {
   DCHECK(!gpu_command_service_);
   gpu_command_service_ = new gpu::GpuInProcessThreadService(
-      gpu_thread_.task_runner(), gpu_service_->sync_point_manager(),
+      gpu_thread_task_runner_, gpu_service_->sync_point_manager(),
       gpu_service_->mailbox_manager(), gpu_service_->share_group());
 
   // |gpu_memory_buffer_factory_| is null in tests.
   gpu::ImageFactory* image_factory =
       gpu_memory_buffer_factory_ ? gpu_memory_buffer_factory_->AsImageFactory()
                                  : nullptr;
 
   mojom::GpuServicePtr gpu_service;
   mojom::GpuServiceRequest gpu_service_request(&gpu_service);
 
-  if (gpu_thread_.task_runner()->BelongsToCurrentThread()) {
+  if (gpu_thread_task_runner_->BelongsToCurrentThread()) {
     // If the DisplayCompositor creation was delayed because GpuService
     // had not been created yet, then this is called, in gpu thread, right after
     // GpuService is created.
     BindGpuInternalOnGpuThread(std::move(gpu_service_request));
   } else {
-    gpu_thread_.task_runner()->PostTask(
+    gpu_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GpuMain::BindGpuInternalOnGpuThread, base::Unretained(this),
                    base::Passed(std::move(gpu_service_request))));
   }
 
-  compositor_thread_.task_runner()->PostTask(
+  compositor_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuMain::CreateDisplayCompositorOnCompositorThread,
                             base::Unretained(this), image_factory,
                             base::Passed(gpu_service.PassInterface()),
                             base::Passed(std::move(request)),
                             base::Passed(std::move(client_info))));
 }
 
 void GpuMain::CreateDisplayCompositorOnCompositorThread(
     gpu::ImageFactory* image_factory,
     mojom::GpuServicePtrInfo gpu_service_info,
@@ skipping 46 matching lines @@
   // TODO(sad): https://crbug.com/645602
 }
 
 bool GpuMain::EnsureSandboxInitialized(
     gpu::GpuWatchdogThread* watchdog_thread) {
   // TODO(sad): https://crbug.com/645602
   return true;
 }
 
 }  // namespace ui