drm: GPU process manages VGEM fd.

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

 // Copyright 2015 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_device_manager.h"
 
 #include "base/file_descriptor_posix.h"
 #include "base/single_thread_task_runner.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
 
 namespace ui {
 
 namespace {
 
 class FindByDevicePath {
  public:
   explicit FindByDevicePath(const base::FilePath& path) : path_(path) {}
 
-  bool operator()(const scoped_refptr<DrmDevice>& device) {
+  bool operator()(const scoped_refptr<DrmDeviceBase>& device) {
     return device->device_path() == path_;
   }
 
  private:
   base::FilePath path_;
 };
 
+class FindVgemDevice {
+ public:
+  FindVgemDevice() {}
+
+  bool operator()(const scoped_refptr<DrmDeviceBase>& device) {
+    return device->GetType() == DrmDeviceBase::VGEM;
+  }
+};
+
+class VgemDevice : public DrmDeviceBase {
+ public:
+  VgemDevice(const base::FilePath& device_path, base::File file)
+      : DrmDeviceBase(device_path, file.Pass()) {}
+  void InitializeTaskRunner(
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override {
+  }
+  Type GetType() const override { return VGEM; }
+
+ protected:
+  ~VgemDevice() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(VgemDevice);
+};
+
 }  // namespace
 
 DrmDeviceManager::DrmDeviceManager(
     scoped_ptr<DrmDeviceGenerator> drm_device_generator)
     : drm_device_generator_(drm_device_generator.Pass()) {
 }
 
 DrmDeviceManager::~DrmDeviceManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(drm_device_map_.empty());
@@ skipping 30 matching lines @@
 void DrmDeviceManager::RemoveDrmDevice(const base::FilePath& path) {
   DCHECK(thread_checker_.CalledOnValidThread());
   auto it =
       std::find_if(devices_.begin(), devices_.end(), FindByDevicePath(path));
   if (it == devices_.end()) {
     VLOG(2) << "Got request to remove non-existent device: " << path.value();
     return;
   }
 
   DCHECK_NE(primary_device_, *it);
+  DCHECK_NE(DrmDeviceBase::VGEM, (*it)->GetType());
   devices_.erase(it);
 }
 
+bool DrmDeviceManager::AddVgemDevice(const base::FilePath& path,
+                                     const base::FileDescriptor& fd) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::File file(fd.fd);
+  auto it =
+      std::find_if(devices_.begin(), devices_.end(), FindByDevicePath(path));
+  if (it != devices_.end()) {
+    VLOG(2) << "Got request to add existing device: " << path.value();
+    return false;
+  }
+  devices_.push_back(new VgemDevice(path, file.Pass()));
+  return true;
+}
+
 void DrmDeviceManager::InitializeIOTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!io_task_runner_);
   io_task_runner_ = task_runner;
   for (const auto& device : devices_)
     device->InitializeTaskRunner(io_task_runner_);
 }
 
 void DrmDeviceManager::UpdateDrmDevice(gfx::AcceleratedWidget widget,
@@ skipping 17 matching lines @@
 
   auto it = drm_device_map_.find(widget);
   DCHECK(it != drm_device_map_.end())
       << "Attempting to get device for unknown widget " << widget;
   // If the widget isn't associated with a display (headless mode) we can
   // allocate buffers from any controller since they will never be scanned out.
   // Use the primary DRM device as a fallback when allocating these buffers.
   if (!it->second)
     return primary_device_;
 
+  DCHECK_EQ(it->second->GetType(), DrmDeviceBase::DRM);
   return it->second;
 }
 
-const DrmDeviceVector& DrmDeviceManager::GetDrmDevices() const {
+DrmDeviceVector DrmDeviceManager::GetDrmDevices() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return devices_;
+  DrmDeviceVector devices;
+  for (const auto& device : devices_) {
+    if (device->GetType() == DrmDeviceBase::DRM)
+      devices.push_back(static_cast<DrmDevice*>(device.get()));
+  }
+  return devices;
+}
+
+scoped_refptr<DrmDeviceBase> DrmDeviceManager::GetVgemDevice() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  auto it = std::find_if(devices_.begin(), devices_.end(), FindVgemDevice());
+  if (it == devices_.end()) {
+    VLOG(2) << "Don't support VGEM.";
+    return nullptr;
+  }
+  return *it;
 }
 
 }  // namespace ui