Switch DRM platform to using a separate thread

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 <gbm.h>
 #include <stdlib.h>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.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/gpu/drm_device_generator.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_platform_support.h"
+#include "ui/ozone/platform/drm/gpu/drm_gpu_platform_support_proxy.h"
+#include "ui/ozone/platform/drm/gpu/drm_thread.h"
 #include "ui/ozone/platform/drm/gpu/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/gbm_device.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
+#include "ui/ozone/platform/drm/gpu/proxy_helpers.h"
 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/platform/drm/host/drm_cursor.h"
 #include "ui/ozone/platform/drm/host/drm_display_host_manager.h"
 #include "ui/ozone/platform/drm/host/drm_gpu_platform_support_host.h"
 #include "ui/ozone/platform/drm/host/drm_native_display_delegate.h"
 #include "ui/ozone/platform/drm/host/drm_overlay_manager.h"
 #include "ui/ozone/platform/drm/host/drm_window_host.h"
 #include "ui/ozone/platform/drm/host/drm_window_host_manager.h"
 #include "ui/ozone/public/cursor_factory_ozone.h"
@@ skipping 68 matching lines @@
 
     return nullptr;
   }
 
  private:
   bool use_atomic_;
 
   DISALLOW_COPY_AND_ASSIGN(GbmDeviceGenerator);
 };
 
+class GbmThread : public DrmThread {
+ public:
+  GbmThread(bool use_surfaceless) : use_surfaceless_(use_surfaceless) {}
+  ~GbmThread() override {}
+
+  // DrmThread:
+  void Init() override {
+    bool use_atomic = false;
+#if defined(USE_DRM_ATOMIC)
+    use_atomic = true;
+#endif
+
+    device_manager_.reset(new DrmDeviceManager(
+        make_scoped_ptr(new GbmDeviceGenerator(use_atomic))));
+    buffer_generator_.reset(new GbmBufferGenerator());
+    screen_manager_.reset(new ScreenManager(buffer_generator_.get()));
+
+    scoped_ptr<DrmGpuDisplayManager> display_manager(
+        new DrmGpuDisplayManager(screen_manager_.get(), device_manager_.get()));
+    gpu_platform_support_.reset(new DrmGpuPlatformSupport(
+        device_manager_.get(), screen_manager_.get(), buffer_generator_.get(),
+        display_manager.Pass()));
+  }
+
+ private:
+  bool use_surfaceless_;
+
+  DISALLOW_COPY_AND_ASSIGN(GbmThread);
+};
+
 class OzonePlatformGbm : public OzonePlatform {
  public:
   OzonePlatformGbm(bool use_surfaceless) : use_surfaceless_(use_surfaceless) {}
   ~OzonePlatformGbm() override {}
 
   // OzonePlatform:
   ui::SurfaceFactoryOzone* GetSurfaceFactoryOzone() override {
-    return surface_factory_ozone_.get();
+    return surface_factory_.get();
   }
   OverlayManagerOzone* GetOverlayManager() override {
     return overlay_manager_.get();
   }
   CursorFactoryOzone* GetCursorFactoryOzone() override {
     return cursor_factory_ozone_.get();
   }
   InputController* GetInputController() override {
     return event_factory_ozone_->input_controller();
   }
   GpuPlatformSupport* GetGpuPlatformSupport() override {
+    if (!gpu_platform_support_)
+      InitializeDrmThread();
+
     return gpu_platform_support_.get();
   }
   GpuPlatformSupportHost* GetGpuPlatformSupportHost() override {
     return gpu_platform_support_host_.get();
   }
   scoped_ptr<SystemInputInjector> CreateSystemInputInjector() override {
     return event_factory_ozone_->CreateSystemInputInjector();
   }
   scoped_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
@@ skipping 36 matching lines @@
         new DrmGpuPlatformSupportHost(cursor_.get()));
     display_manager_.reset(new DrmDisplayHostManager(
         gpu_platform_support_host_.get(), device_manager_.get(),
         event_factory_ozone_->input_controller()));
     cursor_factory_ozone_.reset(new BitmapCursorFactoryOzone);
     overlay_manager_.reset(new DrmOverlayManager(
         use_surfaceless_, gpu_platform_support_host_.get()));
   }
 
   void InitializeGPU() override {
-    bool use_atomic = false;
-#if defined(USE_DRM_ATOMIC)
-    use_atomic = true;
-#endif
     gl_api_loader_.reset(new GlApiLoader());
-    drm_device_manager_.reset(new DrmDeviceManager(
-        scoped_ptr<DrmDeviceGenerator>(new GbmDeviceGenerator(use_atomic))));
-    buffer_generator_.reset(new GbmBufferGenerator());
-    screen_manager_.reset(new ScreenManager(buffer_generator_.get()));
-    surface_factory_ozone_.reset(new GbmSurfaceFactory(use_surfaceless_));
-    surface_factory_ozone_->InitializeGpu(drm_device_manager_.get(),
-                                          screen_manager_.get());
-    scoped_ptr<DrmGpuDisplayManager> display_manager(new DrmGpuDisplayManager(
-        screen_manager_.get(), drm_device_manager_.get()));
-    gpu_platform_support_.reset(new DrmGpuPlatformSupport(
-        drm_device_manager_.get(), screen_manager_.get(),
-        buffer_generator_.get(), display_manager.Pass()));
+    drm_thread_.reset(new GbmThread(use_surfaceless_));
+
+    surface_factory_.reset(
+        new GbmSurfaceFactory(use_surfaceless_, drm_thread_.get()));
   }
 
  private:
+  void InitializeDrmThread() {
+    drm_thread_->Start();
+    gpu_platform_support_ = drm_thread_->CreateGpuPlatformSupportProxy();
+  }
+
   // Objects in both processes.
   bool use_surfaceless_;
 
   // Objects in the GPU process.
-  scoped_ptr<GbmSurfaceFactory> surface_factory_ozone_;
+  scoped_ptr<DrmThread> drm_thread_;
   scoped_ptr<GlApiLoader> gl_api_loader_;
-  scoped_ptr<DrmDeviceManager> drm_device_manager_;
-  scoped_ptr<GbmBufferGenerator> buffer_generator_;
-  scoped_ptr<ScreenManager> screen_manager_;
-  scoped_ptr<DrmGpuPlatformSupport> gpu_platform_support_;
+  scoped_ptr<GbmSurfaceFactory> surface_factory_;
+  scoped_ptr<DrmGpuPlatformSupportProxy> gpu_platform_support_;
 
   // Objects in the Browser process.
   scoped_ptr<DeviceManager> device_manager_;
   scoped_ptr<BitmapCursorFactoryOzone> cursor_factory_ozone_;
   scoped_ptr<DrmWindowHostManager> window_manager_;
   scoped_ptr<DrmCursor> cursor_;
   scoped_ptr<EventFactoryEvdev> event_factory_ozone_;
   scoped_ptr<DrmGpuPlatformSupportHost> gpu_platform_support_host_;
   scoped_ptr<DrmDisplayHostManager> display_manager_;
   scoped_ptr<DrmOverlayManager> overlay_manager_;
@@ skipping 10 matching lines @@
 OzonePlatform* CreateOzonePlatformGbm() {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 #if defined(USE_MESA_PLATFORM_NULL)
   // Only works with surfaceless.
   cmd->AppendSwitch(switches::kOzoneUseSurfaceless);
 #endif
   return new OzonePlatformGbm(cmd->HasSwitch(switches::kOzoneUseSurfaceless));
 }
 
 }  // namespace ui