[2/4]Allow hotplugging of primary DRM device

ui/ozone/platform/drm/gpu/drm_gpu_display_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/gpu/drm_gpu_display_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_descriptor_posix.h"
 #include "base/files/file.h"
 #include "base/single_thread_task_runner.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
-#include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
+#include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_display_mode.h"
 #include "ui/ozone/platform/drm/gpu/drm_display_snapshot.h"
 #include "ui/ozone/platform/drm/gpu/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/ozone_switches.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 43 matching lines @@
     return drm_ == other->drm() && connector_ == other->connector() &&
            crtc_ == other->crtc();
   }
 
  private:
   scoped_refptr<DrmDevice> drm_;
   uint32_t crtc_;
   uint32_t connector_;
 };
 
-class FindByDevicePath {
- public:
-  explicit FindByDevicePath(const base::FilePath& path) : path_(path) {}
-
-  bool operator()(const scoped_refptr<DrmDevice>& device) {
-    return device->device_path() == path_;
-  }
-
- private:
-  base::FilePath path_;
-};
-
 std::string GetEnumNameForProperty(drmModeConnector* connector,
                                    drmModePropertyRes* property) {
   for (int prop_idx = 0; prop_idx < connector->count_props; ++prop_idx) {
     if (connector->props[prop_idx] != property->prop_id)
       continue;
 
     for (int enum_idx = 0; enum_idx < property->count_enums; ++enum_idx) {
       const drm_mode_property_enum& property_enum = property->enums[enum_idx];
       if (property_enum.value == connector->prop_values[prop_idx])
         return property_enum.name;
     }
   }
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace
 
-DrmGpuDisplayManager::DrmGpuDisplayManager(
-    ScreenManager* screen_manager,
-    const scoped_refptr<DrmDevice>& primary_device,
-    scoped_ptr<DrmDeviceGenerator> drm_device_generator)
-    : screen_manager_(screen_manager),
-      drm_device_generator_(drm_device_generator.Pass()) {
-  devices_.push_back(primary_device);
+DrmGpuDisplayManager::DrmGpuDisplayManager(ScreenManager* screen_manager,
+                                           DrmDeviceManager* drm_device_manager)
+    : screen_manager_(screen_manager), drm_device_manager_(drm_device_manager) {
 }
 
 DrmGpuDisplayManager::~DrmGpuDisplayManager() {
 }
 
-void DrmGpuDisplayManager::InitializeIOTaskRunner(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
-  DCHECK(!io_task_runner_);
-  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
-  // If not surfaceless, there isn't support for async page flips.
-  if (!cmd->HasSwitch(switches::kOzoneUseSurfaceless))
-    return;
-
-  io_task_runner_ = task_runner;
-  for (const auto& device : devices_)
-    device->InitializeTaskRunner(io_task_runner_);
-}
-
 std::vector<DisplaySnapshot_Params> DrmGpuDisplayManager::GetDisplays() {
   RefreshDisplayList();
 
   std::vector<DisplaySnapshot_Params> displays;
   for (size_t i = 0; i < cached_displays_.size(); ++i)
     displays.push_back(GetDisplaySnapshotParams(*cached_displays_[i]));
 
   return displays;
 }
 
@@ skipping 47 matching lines @@
   bool success = false;
   if (display)
     success = Configure(*display, NULL, gfx::Point());
   else
     LOG(ERROR) << "There is no display with ID " << id;
 
   return success;
 }
 
 bool DrmGpuDisplayManager::TakeDisplayControl() {
-  for (const auto& drm : devices_) {
+  const DrmDeviceVector& devices = drm_device_manager_->GetDrmDevices();
+  for (const auto& drm : devices) {
     if (!drm->SetMaster()) {
       LOG(ERROR) << "Failed to take control of the display";
       return false;
     }
   }
   return true;
 }
 
 bool DrmGpuDisplayManager::RelinquishDisplayControl() {
-  for (const auto& drm : devices_) {
+  const DrmDeviceVector& devices = drm_device_manager_->GetDrmDevices();
+  for (const auto& drm : devices) {
     if (!drm->DropMaster()) {
       LOG(ERROR) << "Failed to relinquish control of the display";
       return false;
     }
   }
   return true;
 }
 
-void DrmGpuDisplayManager::AddGraphicsDevice(const base::FilePath& path,
-                                             const base::FileDescriptor& fd) {
-  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;
-  }
-
-  scoped_refptr<DrmDevice> device =
-      drm_device_generator_->CreateDevice(path, file.Pass());
-  if (!device) {
-    VLOG(2) << "Could not initialize DRM device for '" << path.value() << "'";
-    return;
-  }
-
-  devices_.push_back(device);
-  if (io_task_runner_)
-    device->InitializeTaskRunner(io_task_runner_);
-}
-
-void DrmGpuDisplayManager::RemoveGraphicsDevice(const base::FilePath& path) {
-  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;
-  }
-
-  devices_.erase(it);
-}
-
 DrmDisplaySnapshot* DrmGpuDisplayManager::FindDisplaySnapshot(int64_t id) {
   for (size_t i = 0; i < cached_displays_.size(); ++i)
     if (cached_displays_[i]->display_id() == id)
       return cached_displays_[i];
 
   return NULL;
 }
 
 const DrmDisplayMode* DrmGpuDisplayManager::FindDisplayMode(
     const gfx::Size& size,
     bool is_interlaced,
     float refresh_rate) {
   for (size_t i = 0; i < cached_modes_.size(); ++i)
     if (cached_modes_[i]->size() == size &&
         cached_modes_[i]->is_interlaced() == is_interlaced &&
         cached_modes_[i]->refresh_rate() == refresh_rate)
       return static_cast<const DrmDisplayMode*>(cached_modes_[i]);
 
   return NULL;
 }
 
 void DrmGpuDisplayManager::RefreshDisplayList() {
   ScopedVector<DrmDisplaySnapshot> old_displays(cached_displays_.Pass());
   ScopedVector<const DisplayMode> old_modes(cached_modes_.Pass());
 
-  for (const auto& drm : devices_) {
+  const DrmDeviceVector& devices = drm_device_manager_->GetDrmDevices();
+  for (const auto& drm : devices) {
     ScopedVector<HardwareDisplayControllerInfo> displays =
         GetAvailableDisplayControllerInfos(drm->get_fd());
     for (size_t i = 0; i < displays.size(); ++i) {
       DrmDisplaySnapshot* display = new DrmDisplaySnapshot(
           drm, displays[i]->connector(), displays[i]->crtc(), i);
 
       // If the display exists make sure to sync up the new snapshot with the
       // old one to keep the user configured details.
       auto it = std::find_if(
           old_displays.begin(), old_displays.end(),
@@ skipping 126 matching lines @@
 
     if (it == old_displays.end()) {
       screen_manager_->AddDisplayController(new_displays[i]->drm(),
                                             new_displays[i]->crtc(),
                                             new_displays[i]->connector());
     }
   }
 }
 
 }  // namespace ui