Switch DRM platform to using a separate thread

ui/ozone/platform/drm/gpu/drm_window.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/gpu/drm_window.h"
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkDevice.h"
@@ skipping 60 matching lines @@
 }
 
 gfx::AcceleratedWidget DrmWindow::GetAcceleratedWidget() {
   return widget_;
 }
 
 HardwareDisplayController* DrmWindow::GetController() {
   return controller_;
 }
 
+scoped_refptr<DrmDevice> DrmWindow::GetAllocationDrmDevice() const {
+  return device_manager_->GetDrmDevice(widget_);
+}
+
 void DrmWindow::OnBoundsChanged(const gfx::Rect& bounds) {
   TRACE_EVENT2("drm", "DrmWindow::OnBoundsChanged", "widget", widget_, "bounds",
                bounds.ToString());
   bounds_ = bounds;
   if (bounds_.size() != bounds.size())
     last_submitted_planes_.clear();
 
   screen_manager_->UpdateControllerToWindowMapping();
 }
 
@@ skipping 27 matching lines @@
   cursor_location_ = location;
 
   if (controller_)
     controller_->MoveCursor(location);
 }
 
 void DrmWindow::QueueOverlayPlane(const OverlayPlane& plane) {
   pending_planes_.push_back(plane);
 }
 
-bool DrmWindow::SchedulePageFlip(bool is_sync,
+void DrmWindow::SchedulePageFlip(bool is_sync,
                                  const SwapCompletionCallback& callback) {
   last_submitted_planes_.clear();
   last_submitted_planes_.swap(pending_planes_);
   last_swap_sync_ = is_sync;
 
   if (controller_) {
-    return controller_->SchedulePageFlip(last_submitted_planes_, is_sync, false,
-                                         callback);
+    controller_->SchedulePageFlip(last_submitted_planes_, is_sync, false,
+                                  callback);
+  } else {
+    callback.Run(gfx::SwapResult::SWAP_ACK);
   }
-
-  callback.Run(gfx::SwapResult::SWAP_ACK);
-  return true;
 }
 
 bool DrmWindow::TestPageFlip(const std::vector<OverlayCheck_Params>& overlays,
                              ScanoutBufferGenerator* buffer_generator) {
   if (!controller_)
     return true;
   for (const auto& overlay : overlays) {
     // It is possible that the cc rect we get actually falls off the edge of
     // the screen. Usually this is prevented via things like status bars
     // blocking overlaying or cc clipping it, but in case it wasn't properly
@@ skipping 36 matching lines @@
   // Stores the time of the last refresh.
   base::TimeTicks timebase =
       base::TimeTicks::FromInternalValue(controller_->GetTimeOfLastFlip());
   // Stores the refresh rate.
   base::TimeDelta interval =
       base::TimeDelta::FromSeconds(1) / controller_->get_mode().vrefresh;
 
   callback.Run(timebase, interval);
 }
 
+bool DrmWindow::IsDisplayedOnUniversalDisplayLinkDevice() const {
+  if (!controller_)
+    return false;
+
+  scoped_refptr<DrmDevice> primary =
+      device_manager_->GetDrmDevice(gfx::kNullAcceleratedWidget);
+  DCHECK(primary);
+
+  return primary != controller_->GetAllocationDrmDevice();
+}
+
 void DrmWindow::ResetCursor(bool bitmap_only) {
   if (!controller_)
     return;
 
   if (cursor_bitmaps_.size()) {
     // Draw new cursor into backbuffer.
     UpdateCursorImage(cursor_buffers_[cursor_frontbuffer_ ^ 1].get(),
                       cursor_bitmaps_[cursor_frame_]);
 
     // Reset location & buffer.
@@ skipping 49 matching lines @@
       if (!cursor_buffers_[i]->Initialize(
               info, false /* should_register_framebuffer */)) {
         LOG(FATAL) << "Failed to initialize cursor buffer";
         return;
       }
     }
   }
 }
 
 }  // namespace ui