ozone: Use the right thread for BinderRegistry.

ui/ozone/platform/drm/ozone_platform_gbm.cc

 // Copyright 2014 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 "ui/ozone/platform/drm/ozone_platform_gbm.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <stdlib.h>
 #include <xf86drm.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "services/service_manager/public/cpp/bind_source_info.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h"
 #include "ui/base/ui_features.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/cursor_proxy_mojo.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
@@ skipping 71 matching lines @@
     return gpu_message_filter_.get();
   }
   GpuPlatformSupportHost* GetGpuPlatformSupportHost() override {
     return gpu_platform_support_host_.get();
   }
   std::unique_ptr<SystemInputInjector> CreateSystemInputInjector() override {
     return event_factory_ozone_->CreateSystemInputInjector();
   }
   void AddInterfaces(service_manager::BinderRegistry* registry) override {
     registry->AddInterface<ozone::mojom::DeviceCursor>(
-        base::Bind(&OzonePlatformGbm::Create, base::Unretained(this)));
+        base::Bind(&OzonePlatformGbm::Create, base::Unretained(this)),
+        gpu_task_runner_);
   }
   void Create(const service_manager::BindSourceInfo& source_info,
               ozone::mojom::DeviceCursorRequest request) {
     if (drm_thread_proxy_)
       drm_thread_proxy_->AddBinding(std::move(request));
     else
       pending_cursor_requests_.push_back(std::move(request));
   }
   std::unique_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
@@ skipping 79 matching lines @@
                                          overlay_manager_.get());
     }
   }
   void InitializeGPU(const InitParams& args) override {
     // TODO(rjkroege): services/ui should initialize this with a connector.
     // However, in-progress refactorings in services/ui make it difficult to
     // require this at present. Set using_mojo_ like below once this is
     // complete.
     // using_mojo_ = args.connector != nullptr;
 
+    gpu_task_runner_ = base::ThreadTaskRunnerHandle::Get();

[varad, 2017/06/02 09:59:41]

exo clients segfault here during ui::OzonePlatform::InitializeForGPU when run
with --use-drm. do we want a ThreadTaskRunnerHandle::IsSet() check before the
Get()?

     InterThreadMessagingProxy* itmp;
     if (using_mojo_ || single_process_) {
       itmp = mus_thread_proxy_.get();
     } else {
       gl_api_loader_.reset(new GlApiLoader());
       scoped_refptr<DrmThreadMessageProxy> message_proxy(
           new DrmThreadMessageProxy());
       itmp = message_proxy.get();
       gpu_message_filter_ = std::move(message_proxy);
     }
@@ skipping 19 matching lines @@
   // Bridges the DRM, GPU and main threads in mus. This must be destroyed last.
   std::unique_ptr<MusThreadProxy> mus_thread_proxy_;
 
   // Objects in the GPU process.
   std::unique_ptr<DrmThreadProxy> drm_thread_proxy_;
   std::unique_ptr<GlApiLoader> gl_api_loader_;
   std::unique_ptr<GbmSurfaceFactory> surface_factory_;
   scoped_refptr<IPC::MessageFilter> gpu_message_filter_;
   // TODO(sad): Once the mus gpu process split happens, this can go away.
   std::vector<ozone::mojom::DeviceCursorRequest> pending_cursor_requests_;
+  scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner_;
 
   // Objects in the Browser process.
   std::unique_ptr<DeviceManager> device_manager_;
   std::unique_ptr<BitmapCursorFactoryOzone> cursor_factory_ozone_;
   std::unique_ptr<DrmWindowHostManager> window_manager_;
   std::unique_ptr<DrmCursor> cursor_;
   std::unique_ptr<EventFactoryEvdev> event_factory_ozone_;
   std::unique_ptr<DrmGpuPlatformSupportHost> gpu_platform_support_host_;
   std::unique_ptr<DrmDisplayHostManager> display_manager_;
   std::unique_ptr<DrmOverlayManager> overlay_manager_;
 
 #if BUILDFLAG(USE_XKBCOMMON)
   XkbEvdevCodes xkb_evdev_code_converter_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(OzonePlatformGbm);
 };
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformGbm() {
   return new OzonePlatformGbm;
 }
 
 }  // namespace ui