content: implement unittests backend for Ozone GBM

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 "base/message_loop/message_loop.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.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/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/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"
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/gpu_platform_support_host.h"
+#include "ui/ozone/public/ozone_gpu_test_helper.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/ozone_switches.h"
 
 #if defined(USE_XKBCOMMON)
 #include "ui/events/ozone/layout/xkb/xkb_evdev_codes.h"
 #include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
 #else
 #include "ui/events/ozone/layout/stub/stub_keyboard_layout_engine.h"
 #endif
 
@@ skipping 52 matching lines @@
 
     return nullptr;
   }
 
  private:
   bool use_atomic_;
 
   DISALLOW_COPY_AND_ASSIGN(GbmDeviceGenerator);
 };
 
+void Noop(base::WaitableEvent* done) {
+  done->Signal();
+}
+
 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();
   }
   OverlayManagerOzone* GetOverlayManager() override {
@@ skipping 62 matching lines @@
     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()));
   }
 
+  // Must initialize everything synchronously. It's why this method creates
+  // |ui_thread_| and |gpu_ipc_thread_|, and then requests initialization, and
+  // then waits for all initialization done.
+  void InitializeTest() override {
+    message_loop_for_test_.reset(new base::MessageLoopForUI);
+
+    ui_thread_.reset(new base::Thread("test_ui_thread"));

[spang, 2015/07/13 17:08:26]

Creating a "UI thread" won't work because any calls into UI code made by content
in the test will be on the main thread, not the thread created here. So all of
those calls become races.

+    ui_thread_->Start();
+    {
+      base::WaitableEvent done(false, false);
+      ui_thread_->task_runner()->PostTask(
+          FROM_HERE, base::Bind(&OzonePlatformGbm::InitializeUIForTest,
+                                base::Unretained(this), &done));
+      done.Wait();
+    }
+
+    InitializeGPU();
+
+    gpu_ipc_thread_.reset(new base::Thread("test_gpu_ipc_thread"));
+    gpu_ipc_thread_->Start();
+    gpu_helper_.reset(new ui::OzoneGpuTestHelper);
+    gpu_helper_->Initialize(ui_thread_->task_runner(),
+                            gpu_ipc_thread_->task_runner());
+    {
+      base::WaitableEvent done(false, false);
+      gpu_ipc_thread_->task_runner()->PostTask(FROM_HERE,
+                                               base::Bind(&Noop, &done));
+      done.Wait();
+    }
+  }
+
  private:
+  void InitializeUIForTest(base::WaitableEvent* done) {
+    InitializeUI();
+    done->Signal();
+  }
+
   // Objects in both processes.
   bool use_surfaceless_;
 
   // Objects in the GPU process.
   scoped_ptr<GbmSurfaceFactory> surface_factory_ozone_;
   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_;
 
   // 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_;
 
+  // for test
+  scoped_ptr<base::MessageLoopForUI> message_loop_for_test_;
+  scoped_ptr<base::Thread> ui_thread_;
+  scoped_ptr<base::Thread> gpu_ipc_thread_;
+  scoped_ptr<ui::OzoneGpuTestHelper> gpu_helper_;
+
 #if defined(USE_XKBCOMMON)
   XkbEvdevCodes xkb_evdev_code_converter_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(OzonePlatformGbm);
 };
 
 }  // namespace
 
 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