ui/ozone/platform/drm/gpu/drm_device_manager.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
   6
   7 #include "base/file_descriptor_posix.h"
   8 #include "base/single_thread_task_runner.h"
   9 #include "ui/ozone/platform/drm/gpu/drm_device.h"
  10 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
  11
  12 namespace ui {
  13
  14 namespace {
  15
  16 class FindByDevicePath {
  17  public:
  18   explicit FindByDevicePath(const base::FilePath& path) : path_(path) {}
  19
  20   bool operator()(const scoped_refptr<DrmDevice>& device) {
  21     return device->device_path() == path_;
  22   }
  23
  24  private:
  25   base::FilePath path_;
  26 };
  27
  28 }  // namespace
  29
  30 DrmDeviceManager::DrmDeviceManager(
  31     scoped_ptr<DrmDeviceGenerator> drm_device_generator)
  32     : drm_device_generator_(drm_device_generator.Pass()) {
  33 }
  34
  35 DrmDeviceManager::~DrmDeviceManager() {
  36   DCHECK(thread_checker_.CalledOnValidThread());
  37   DCHECK(drm_device_map_.empty());
  38 }
  39
  40 bool DrmDeviceManager::AddDrmDevice(const base::FilePath& path,
  41                                     const base::FileDescriptor& fd) {
  42   DCHECK(thread_checker_.CalledOnValidThread());
  43   base::File file(fd.fd);
  44   auto it =
  45       std::find_if(devices_.begin(), devices_.end(), FindByDevicePath(path));
  46   if (it != devices_.end()) {
  47     VLOG(2) << "Got request to add existing device: " << path.value();
  48     return false;
  49   }
  50
  51   scoped_refptr<DrmDevice> device =
  52       drm_device_generator_->CreateDevice(path, file.Pass());
  53   if (!device) {
  54     LOG(ERROR) << "Could not initialize DRM device for " << path.value();
  55     return false;
  56   }
  57
  58   if (io_task_runner_)
  59     device->InitializeTaskRunner(io_task_runner_);
  60
  61   if (!primary_device_)
  62     primary_device_ = device;
  63
  64   devices_.push_back(device);
  65   return true;
  66 }
  67
  68 void DrmDeviceManager::RemoveDrmDevice(const base::FilePath& path) {
  69   DCHECK(thread_checker_.CalledOnValidThread());
  70   auto it =
  71       std::find_if(devices_.begin(), devices_.end(), FindByDevicePath(path));
  72   if (it == devices_.end()) {
  73     VLOG(2) << "Got request to remove non-existent device: " << path.value();
  74     return;
  75   }
  76
  77   DCHECK_NE(primary_device_, *it);
  78   devices_.erase(it);
  79 }
  80
  81 void DrmDeviceManager::InitializeIOTaskRunner(
  82     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
  83   DCHECK(thread_checker_.CalledOnValidThread());
  84   DCHECK(!io_task_runner_);
  85   io_task_runner_ = task_runner;
  86   for (const auto& device : devices_)
  87     device->InitializeTaskRunner(io_task_runner_);
  88 }
  89
  90 void DrmDeviceManager::UpdateDrmDevice(gfx::AcceleratedWidget widget,
  91                                        const scoped_refptr<DrmDevice>& device) {
  92   base::AutoLock lock(lock_);
  93   drm_device_map_[widget] = device;
  94 }
  95
  96 void DrmDeviceManager::RemoveDrmDevice(gfx::AcceleratedWidget widget) {
  97   base::AutoLock lock(lock_);
  98   auto it = drm_device_map_.find(widget);
  99   if (it != drm_device_map_.end())
 100     drm_device_map_.erase(it);
 101 }
 102
 103 scoped_refptr<DrmDevice> DrmDeviceManager::GetDrmDevice(
 104     gfx::AcceleratedWidget widget) {
 105   base::AutoLock lock(lock_);
 106   if (widget == gfx::kNullAcceleratedWidget)
 107     return primary_device_;
 108
 109   auto it = drm_device_map_.find(widget);
 110   DCHECK(it != drm_device_map_.end())
 111       << "Attempting to get device for unknown widget " << widget;
 112   // If the widget isn't associated with a display (headless mode) we can
 113   // allocate buffers from any controller since they will never be scanned out.
 114   // Use the primary DRM device as a fallback when allocating these buffers.
 115   if (!it->second)
 116     return primary_device_;
 117
 118   return it->second;
 119 }
 120
 121 const DrmDeviceVector& DrmDeviceManager::GetDrmDevices() const {
 122   DCHECK(thread_checker_.CalledOnValidThread());
 123   return devices_;
 124 }
 125
 126 }  // namespace ui