Make ozone/drm/mojo more immune to startup races

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>
@@ skipping 106 matching lines @@
     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,
       const gfx::Rect& bounds) override {
     GpuThreadAdapter* adapter = gpu_platform_support_host_.get();
     if (using_mojo_ || single_process_) {
-      DCHECK(drm_thread_proxy_)
-          << "drm_thread_proxy_ should exist (and be running) here.";
       adapter = mus_thread_proxy_.get();
     }
 
     std::unique_ptr<DrmWindowHost> platform_window(new DrmWindowHost(
         delegate, bounds, adapter, event_factory_ozone_.get(), cursor_.get(),
         window_manager_.get(), display_manager_.get(), overlay_manager_.get()));
     platform_window->Initialize();
     return std::move(platform_window);
   }
   std::unique_ptr<display::NativeDisplayDelegate> CreateNativeDisplayDelegate()
@@ skipping 33 matching lines @@
     GpuThreadAdapter* adapter;
 
     // TODO(rjkroege): Once mus is split, only do this for single_process.
     if (single_process_ || using_mojo_)
       gl_api_loader_.reset(new GlApiLoader());
 
     if (using_mojo_) {
       DCHECK(args.connector);
       mus_thread_proxy_.reset(new MusThreadProxy());
       adapter = mus_thread_proxy_.get();
       cursor_->SetDrmCursorProxy(new CursorProxyMojo(args.connector));

[sadrul, 2017/05/25 22:37:00]

Since we already know that this |mus_thread_proxy_| is going to be used in the
gpu thread too, can we just 'StartDrmThread()' here? That would mean we don't
need the unfortunate checks in MusThreadProxy.

[rjkroege, 2017/05/25 22:52:49]

I'd prefer not to do this because:
* the "unfortunate checks" are needed in split-process mode regardless. :-(
* doing that would increase the divergence between what we have now and what we
need for multi-process mode
* more divergence between param traits IPC and mojo versions of the code.

[sadrul, 2017/05/26 01:46:56]

In split-process mode, the MusThreadProxy created here in InitializeUI() is not
the one that will be used in InitializeGpu() below (~line 214), because these
will be called from different processes. Presumably*, we would create a new
instance of MusThreadProxy in InitializeGpu() at that time, and immediately call
StartDrmThread() on that (as we now do, in ~line 230). Which means the checks in
MusThreadProxy will not be needed, because it will always have a Start()'ed
|drm_thread_|. That's why I was thinking the checks added in MusThreadProxy in
this CL will not be needed in that config.

Do I have this wrong? In the viz/gpu process, will the creation of
MusThreadProxy happen in somewhere other than InitializeGpu()?

[*] It's not really clear to me what your plans are regarding the split mode.

[dnicoara, 2017/05/26 15:51:04]

I share Sadrul's concern. It feels like you're running into a threading issue
where the OzonePlatform is called while InitializeGPU() is running.

     } else if (single_process_) {
       mus_thread_proxy_.reset(new MusThreadProxy());
       adapter = mus_thread_proxy_.get();
       cursor_->SetDrmCursorProxy(
           new CursorProxyThread(mus_thread_proxy_.get()));
     } else {
       gpu_platform_support_host_.reset(
           new DrmGpuPlatformSupportHost(cursor_.get()));
       adapter = gpu_platform_support_host_.get();
     }
@@ skipping 76 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(OzonePlatformGbm);
 };
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformGbm() {
   return new OzonePlatformGbm;
 }
 
 }  // namespace ui