Make ozone/drm/mojo more immune to startup races

ui/ozone/platform/drm/mus_thread_proxy.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 "ui/ozone/platform/drm/mus_thread_proxy.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 41 matching lines @@
   base::AutoLock acquire(lock_);
   drm_thread_ = thread;
 }
 
 void MusThreadProxy::ProvideManagers(DrmDisplayHostManager* display_manager,
                                      DrmOverlayManager* overlay_manager) {
   display_manager_ = display_manager;
   overlay_manager_ = overlay_manager;
 }
 
+// Runs on Gpu thread.
 void MusThreadProxy::StartDrmThread() {
   DCHECK(drm_thread_);
   drm_thread_->Start();
 
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&MusThreadProxy::DispatchObserversFromDrmThread,
                             base::Unretained(this)));
 }
 
 void MusThreadProxy::DispatchObserversFromDrmThread() {
@@ skipping 42 matching lines @@
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   display_manager_ = handler;
 }
 
 void MusThreadProxy::UnRegisterHandlerForDrmDisplayHostManager() {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   display_manager_ = nullptr;
 }
 
 bool MusThreadProxy::GpuCreateWindow(gfx::AcceleratedWidget widget) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::CreateWindow,
                             base::Unretained(drm_thread_), widget));
   return true;
 }
 
 bool MusThreadProxy::GpuDestroyWindow(gfx::AcceleratedWidget widget) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::DestroyWindow,
                             base::Unretained(drm_thread_), widget));
   return true;
 }
 
 bool MusThreadProxy::GpuWindowBoundsChanged(gfx::AcceleratedWidget widget,
                                             const gfx::Rect& bounds) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::SetWindowBounds,
                             base::Unretained(drm_thread_), widget, bounds));
   return true;
 }
 
 void MusThreadProxy::CursorSet(gfx::AcceleratedWidget widget,
                                const std::vector<SkBitmap>& bitmaps,
                                const gfx::Point& location,
                                int frame_delay_ms) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DrmThread::SetCursor, base::Unretained(drm_thread_), widget,
                  bitmaps, location, frame_delay_ms));
 }
 
 void MusThreadProxy::Move(gfx::AcceleratedWidget widget,
                           const gfx::Point& location) {
   // NOTE: Input events skip the main thread to avoid jank.
-  DCHECK(drm_thread_->IsRunning());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::MoveCursor,
                             base::Unretained(drm_thread_), widget, location));
 }
 
 // Services needed for DrmOverlayManager.
 void MusThreadProxy::RegisterHandlerForDrmOverlayManager(
     DrmOverlayManager* handler) {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   overlay_manager_ = handler;
 }
 
 void MusThreadProxy::UnRegisterHandlerForDrmOverlayManager() {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   overlay_manager_ = nullptr;
 }
 
 bool MusThreadProxy::GpuCheckOverlayCapabilities(
     gfx::AcceleratedWidget widget,
     const std::vector<OverlayCheck_Params>& overlays) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback =
       base::BindOnce(&MusThreadProxy::GpuCheckOverlayCapabilitiesCallback,
                      weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::BindOnce(&DrmThread::CheckOverlayCapabilities,
                                 base::Unretained(drm_thread_), widget, overlays,
                                 std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuRefreshNativeDisplays() {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback =
       base::BindOnce(&MusThreadProxy::GpuRefreshNativeDisplaysCallback,
                      weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&DrmThread::RefreshNativeDisplays,
                      base::Unretained(drm_thread_), std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuConfigureNativeDisplay(int64_t id,
                                                const DisplayMode_Params& pmode,
                                                const gfx::Point& origin) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
 
   auto mode = CreateDisplayModeFromParams(pmode);
   auto callback =
       base::BindOnce(&MusThreadProxy::GpuConfigureNativeDisplayCallback,
                      weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&DrmThread::ConfigureNativeDisplay,
                      base::Unretained(drm_thread_), id, std::move(mode), origin,
                      std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuDisableNativeDisplay(int64_t id) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback =
       base::BindOnce(&MusThreadProxy::GpuDisableNativeDisplayCallback,
                      weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::BindOnce(&DrmThread::DisableNativeDisplay,
                                 base::Unretained(drm_thread_), id,
                                 std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuTakeDisplayControl() {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback = base::BindOnce(&MusThreadProxy::GpuTakeDisplayControlCallback,
                                  weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&DrmThread::TakeDisplayControl,
                      base::Unretained(drm_thread_), std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuRelinquishDisplayControl() {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback =
       base::BindOnce(&MusThreadProxy::GpuRelinquishDisplayControlCallback,
                      weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&DrmThread::RelinquishDisplayControl,
                      base::Unretained(drm_thread_), std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuAddGraphicsDevice(const base::FilePath& path,
                                           const base::FileDescriptor& fd) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::AddGraphicsDevice,
                             base::Unretained(drm_thread_), path, fd));
   return true;
 }
 
 bool MusThreadProxy::GpuRemoveGraphicsDevice(const base::FilePath& path) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::RemoveGraphicsDevice,
                             base::Unretained(drm_thread_), path));
   return true;
 }
 
 bool MusThreadProxy::GpuGetHDCPState(int64_t display_id) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback = base::BindOnce(&MusThreadProxy::GpuGetHDCPStateCallback,
                                  weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&DrmThread::GetHDCPState, base::Unretained(drm_thread_),
                      display_id, std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuSetHDCPState(int64_t display_id,
                                      display::HDCPState state) {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
-  DCHECK(drm_thread_->IsRunning());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   auto callback = base::BindOnce(&MusThreadProxy::GpuSetHDCPStateCallback,
                                  weak_ptr_factory_.GetWeakPtr());
   auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&DrmThread::SetHDCPState, base::Unretained(drm_thread_),
                      display_id, state, std::move(safe_callback)));
   return true;
 }
 
 bool MusThreadProxy::GpuSetColorCorrection(
     int64_t id,
     const std::vector<display::GammaRampRGBEntry>& degamma_lut,
     const std::vector<display::GammaRampRGBEntry>& gamma_lut,
     const std::vector<float>& correction_matrix) {
-  DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
+  if (!drm_thread_ || !drm_thread_->IsRunning())
+    return false;
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DrmThread::SetColorCorrection, base::Unretained(drm_thread_),
                  id, degamma_lut, gamma_lut, correction_matrix));
   return true;
 }
 
 void MusThreadProxy::GpuCheckOverlayCapabilitiesCallback(
     gfx::AcceleratedWidget widget,
     const std::vector<OverlayCheck_Params>& overlays) const {
@@ skipping 36 matching lines @@
   display_manager_->GpuReceivedHDCPState(display_id, success, state);
 }
 
 void MusThreadProxy::GpuSetHDCPStateCallback(int64_t display_id,
                                              bool success) const {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   display_manager_->GpuUpdatedHDCPState(display_id, success);
 }
 
 }  // namespace ui