Implement DRM Native Pixmap using prime buffer

ui/ozone/platform/drm/host/drm_display_host_manager.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/host/drm_display_host_manager.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <xf86drm.h>
 #include <utility>
 
-#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/host/drm_device_handle.h"
 #include "ui/ozone/platform/drm/host/drm_display_host.h"
 #include "ui/ozone/platform/drm/host/drm_native_display_delegate.h"
 #include "ui/ozone/platform/drm/host/gpu_thread_adapter.h"
 
 namespace ui {
 
 namespace {
 
 typedef base::Callback<void(const base::FilePath&,
                             const base::FilePath&,
                             scoped_ptr<DrmDeviceHandle>)>
     OnOpenDeviceReplyCallback;
 
 const char kDefaultGraphicsCardPattern[] = "/dev/dri/card%d";
-const char kVgemDevDriCardPath[] = "/dev/dri/";
-const char kVgemSysCardPath[] = "/sys/bus/platform/devices/vgem/drm/";
 
 const char* kDisplayActionString[] = {
     "ADD", "REMOVE", "CHANGE",
 };
 
 // Find sysfs device path for the given device path.
 base::FilePath MapDevPathToSysPath(const base::FilePath& device_path) {
   // |device_path| looks something like /dev/dri/card0. We take the basename of
   // that (card0) and append it to /sys/class/drm. /sys/class/drm/card0 is a
   // symlink that points to something like
@@ skipping 37 matching lines @@
       return base::FilePath(card_path);
     }
 
     VPLOG_IF(1, ret) << "Failed to get DRM resources for '" << card_path << "'";
   }
 
   LOG(FATAL) << "Failed to open primary graphics device.";
   return base::FilePath();  // Not reached.
 }
 
-base::FilePath GetVgemCardPath() {
-  base::FileEnumerator file_iter(base::FilePath(kVgemSysCardPath), false,
-                                 base::FileEnumerator::DIRECTORIES,
-                                 FILE_PATH_LITERAL("card*"));
-
-  while (!file_iter.Next().empty()) {
-    // Inspect the card%d directories in the directory and extract the filename.
-    std::string vgem_card_path =
-        kVgemDevDriCardPath + file_iter.GetInfo().GetName().BaseName().value();
-    DVLOG(1) << "VGEM card path is " << vgem_card_path;
-    return base::FilePath(vgem_card_path);
-  }
-  DVLOG(1) << "Don't support VGEM";
-  return base::FilePath();
-}
-
 class FindDrmDisplayHostById {
  public:
   explicit FindDrmDisplayHostById(int64_t display_id)
       : display_id_(display_id) {}
 
   bool operator()(const scoped_ptr<DrmDisplayHost>& display) const {
     return display->snapshot()->display_id() == display_id_;
   }
 
  private:
@@ skipping 21 matching lines @@
         MapDevPathToSysPath(primary_graphics_card_path_);
 
     primary_drm_device_handle_.reset(new DrmDeviceHandle());
     if (!primary_drm_device_handle_->Initialize(
             primary_graphics_card_path_, primary_graphics_card_path_sysfs)) {
       LOG(FATAL) << "Failed to open primary graphics card";
       return;
     }
     drm_devices_[primary_graphics_card_path_] =
         primary_graphics_card_path_sysfs;
-
-    vgem_card_path_ = GetVgemCardPath();
   }
 
   device_manager_->AddObserver(this);
   proxy_->RegisterHandlerForDrmDisplayHostManager(this);
   proxy_->AddGpuThreadObserver(this);
 
   ScopedVector<HardwareDisplayControllerInfo> display_infos =
       GetAvailableDisplayControllerInfos(primary_drm_device_handle_->fd());
   has_dummy_display_ = !display_infos.empty();
   for (size_t i = 0; i < display_infos.size(); ++i) {
@@ skipping 90 matching lines @@
 }
 
 void DrmDisplayHostManager::ProcessEvent() {
   while (!event_queue_.empty() && !task_pending_) {
     DisplayEvent event = event_queue_.front();
     event_queue_.pop();
     VLOG(1) << "Got display event " << kDisplayActionString[event.action_type]
             << " for " << event.path.value();
     switch (event.action_type) {
       case DeviceEvent::ADD:
-        if (event.path == vgem_card_path_)
-          continue;
         if (drm_devices_.find(event.path) == drm_devices_.end()) {
           task_pending_ = base::WorkerPool::PostTask(
               FROM_HERE,
               base::Bind(&OpenDeviceOnWorkerThread, event.path,
                          base::ThreadTaskRunnerHandle::Get(),
                          base::Bind(&DrmDisplayHostManager::OnAddGraphicsDevice,
                                     weak_ptr_factory_.GetWeakPtr())),
               false /* task_is_slow */);
         }
         break;
       case DeviceEvent::CHANGE:
         task_pending_ = base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE,
             base::Bind(&DrmDisplayHostManager::OnUpdateGraphicsDevice,
                        weak_ptr_factory_.GetWeakPtr()));
         break;
       case DeviceEvent::REMOVE:
         DCHECK(event.path != primary_graphics_card_path_)
             << "Removing primary graphics card";
-        DCHECK(event.path != vgem_card_path_) << "Removing VGEM device";
         auto it = drm_devices_.find(event.path);
         if (it != drm_devices_.end()) {
           task_pending_ = base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&DrmDisplayHostManager::OnRemoveGraphicsDevice,
                          weak_ptr_factory_.GetWeakPtr(), it->second));
           drm_devices_.erase(it);
         }
         break;
     }
@@ skipping 180 matching lines @@
 
   callback.Run(snapshots);
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui