[4/4][Ozone-Drm] Keep track of DRM devices in browser process

ui/ozone/platform/drm/host/drm_native_display_delegate.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_native_display_delegate.h"
 
 #include <stdio.h>
-#include <xf86drm.h>
 
 #include "base/logging.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/display/types/native_display_observer.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/ozone/common/display_snapshot_proxy.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/common/gpu/ozone_gpu_messages.h"
 #include "ui/ozone/platform/drm/host/display_manager.h"
+#include "ui/ozone/platform/drm/host/drm_device_handle.h"
 #include "ui/ozone/platform/drm/host/drm_gpu_platform_support_host.h"
 
 namespace ui {
 
 namespace {
 
-typedef base::Callback<void(const base::FilePath&, base::File)>
+typedef base::Callback<void(const base::FilePath&, scoped_ptr<DrmDeviceHandle>)>
     OnOpenDeviceReplyCallback;
 
 const char* kDisplayActionString[] = {
     "ADD",
     "REMOVE",
     "CHANGE",
 };
 
-bool Authenticate(int fd) {
-  drm_magic_t magic = 0;
-  // We need to make sure the DRM device has enough privilege. Use the DRM
-  // authentication logic to figure out if the device has enough permissions.
-  return !drmGetMagic(fd, &magic) && !drmAuthMagic(fd, magic);
-}
-
-base::File OpenDrmDevice(const base::FilePath& path) {
-  base::File file;
-  bool print_warning = true;
-  while (true) {
-    file = base::File(path, base::File::FLAG_OPEN | base::File::FLAG_READ |
-                                base::File::FLAG_WRITE);
-
-    base::File::Info info;
-    file.GetInfo(&info);
-
-    CHECK(!info.is_directory);
-    CHECK(path.DirName() == base::FilePath("/dev/dri"));
-
-    if (!file.IsValid()) {
-      LOG(ERROR) << "Failed to open " << path.value() << ": "
-                 << base::File::ErrorToString(file.error_details());
-      return file.Pass();
-    }
-
-    if (Authenticate(file.GetPlatformFile()))
-      break;
-
-    LOG_IF(WARNING, print_warning) << "Failed to authenticate " << path.value();
-
-    print_warning = false;
-    usleep(100000);
-  }
-
-  VLOG(1) << "Succeeded authenticating " << path.value();
-  return file.Pass();
-}
-
 void OpenDeviceOnWorkerThread(
     const base::FilePath& path,
     const scoped_refptr<base::TaskRunner>& reply_runner,
     const OnOpenDeviceReplyCallback& callback) {
-  base::File file = OpenDrmDevice(path);
-  reply_runner->PostTask(FROM_HERE,
-                         base::Bind(callback, path, base::Passed(file.Pass())));
+  scoped_ptr<DrmDeviceHandle> handle(new DrmDeviceHandle());
+  handle->Initialize(path);
+  reply_runner->PostTask(
+      FROM_HERE, base::Bind(callback, path, base::Passed(handle.Pass())));
+}
+
+void CloseDeviceOnWorkerThread(
+    scoped_ptr<DrmDeviceHandle> handle,
+    const scoped_refptr<base::TaskRunner>& reply_runner,
+    const base::Closure& callback) {
+  handle.reset();
+  reply_runner->PostTask(FROM_HERE, callback);
 }
 
 class DrmDisplaySnapshotProxy : public DisplaySnapshotProxy {
  public:
   DrmDisplaySnapshotProxy(const DisplaySnapshot_Params& params,
                           DisplayManager* display_manager)
       : DisplaySnapshotProxy(params), display_manager_(display_manager) {
     display_manager_->RegisterDisplay(this);
   }
 
@@ skipping 15 matching lines @@
     DisplayManager* display_manager,
     const base::FilePath& primary_graphics_card_path)
     : proxy_(proxy),
       device_manager_(device_manager),
       display_manager_(display_manager),
       primary_graphics_card_path_(primary_graphics_card_path),
       has_dummy_display_(false),
       task_pending_(false),
       weak_ptr_factory_(this) {
   proxy_->RegisterHandler(this);
-  drm_devices_.insert(primary_graphics_card_path);
 }
 
 DrmNativeDisplayDelegate::~DrmNativeDisplayDelegate() {
   device_manager_->RemoveObserver(this);
   proxy_->UnregisterHandler(this);
+
+  for (auto it = drm_devices_.begin(); it != drm_devices_.end(); ++it) {
+    base::WorkerPool::PostTask(FROM_HERE,
+                               base::Bind(&CloseDeviceOnWorkerThread,
+                                          base::Passed(drm_devices_.take(it)),
+                                          base::ThreadTaskRunnerHandle::Get(),
+                                          base::Bind(&base::DoNothing)),
+                               false /* task_is_slow */);
+  }
 }
 
 void DrmNativeDisplayDelegate::Initialize() {
+  {
+    // First device needs to be treated specially. We need to open this
+    // synchronously since the GPU process will need it to initialize the
+    // graphics state.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    scoped_ptr<DrmDeviceHandle> handle(new DrmDeviceHandle());
+    if (!handle->Initialize(primary_graphics_card_path_)) {
+      LOG(FATAL) << "Failed to open primary graphics card";
+      return;
+    }
+    drm_devices_.add(primary_graphics_card_path_, handle.Pass());
+  }
+
   device_manager_->AddObserver(this);
   device_manager_->ScanDevices(this);
 
   if (!displays_.empty())
     return;
   DisplaySnapshot_Params params;
   bool success = false;
   {
     // The file generated by frecon that contains EDID for the 1st display.
     const base::FilePath kEDIDFile("/tmp/display_info.bin");
@@ skipping 133 matching lines @@
 
 void DrmNativeDisplayDelegate::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 (drm_devices_.find(event.path) == drm_devices_.end()) {
-          drm_devices_.insert(event.path);
           task_pending_ = base::WorkerPool::PostTask(
               FROM_HERE,
               base::Bind(
                   &OpenDeviceOnWorkerThread, event.path,
                   base::ThreadTaskRunnerHandle::Get(),
                   base::Bind(&DrmNativeDisplayDelegate::OnAddGraphicsDevice,
                              weak_ptr_factory_.GetWeakPtr())),
               false /* task_is_slow */);
         }
         break;
       case DeviceEvent::CHANGE:
         task_pending_ = base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE,
             base::Bind(&DrmNativeDisplayDelegate::OnUpdateGraphicsDevice,
                        weak_ptr_factory_.GetWeakPtr()));
         break;
       case DeviceEvent::REMOVE:
         DCHECK(event.path != primary_graphics_card_path_)
             << "Removing primary graphics card";
         auto it = drm_devices_.find(event.path);
         if (it != drm_devices_.end()) {
-          drm_devices_.erase(it);
-          task_pending_ = base::ThreadTaskRunnerHandle::Get()->PostTask(
+          task_pending_ = base::WorkerPool::PostTask(
               FROM_HERE,
-              base::Bind(&DrmNativeDisplayDelegate::OnRemoveGraphicsDevice,
-                         weak_ptr_factory_.GetWeakPtr(), event.path));
+              base::Bind(
+                  &CloseDeviceOnWorkerThread,
+                  base::Passed(drm_devices_.take_and_erase(it)),
+                  base::ThreadTaskRunnerHandle::Get(),
+                  base::Bind(&DrmNativeDisplayDelegate::OnRemoveGraphicsDevice,
+                             weak_ptr_factory_.GetWeakPtr(), event.path)),
+              false /* task_is_slow */);
+          return;
         }
         break;
     }
   }
 }
 
-void DrmNativeDisplayDelegate::OnAddGraphicsDevice(const base::FilePath& path,
-                                                   base::File file) {
-  if (file.IsValid()) {
+void DrmNativeDisplayDelegate::OnAddGraphicsDevice(
+    const base::FilePath& path,
+    scoped_ptr<DrmDeviceHandle> handle) {
+  if (handle->IsValid()) {
+    base::ScopedFD file = handle->Duplicate();
+    drm_devices_.add(path, handle.Pass());
     proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
         path, base::FileDescriptor(file.Pass())));
     FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
                       OnConfigurationChanged());
   }
 
   task_pending_ = false;
   ProcessEvent();
 }
 
@@ skipping 10 matching lines @@
   FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
                     OnConfigurationChanged());
   task_pending_ = false;
   ProcessEvent();
 }
 
 void DrmNativeDisplayDelegate::OnChannelEstablished(
     int host_id,
     scoped_refptr<base::SingleThreadTaskRunner> send_runner,
     const base::Callback<void(IPC::Message*)>& send_callback) {
-  drm_devices_.clear();
-  drm_devices_.insert(primary_graphics_card_path_);
-  {
-    // First device needs to be treated specially. We need to open this
-    // synchronously since the GPU process will need it to initialize the
-    // graphics state.
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
-    base::File file = OpenDrmDevice(primary_graphics_card_path_);
-    if (!file.IsValid()) {
-      LOG(FATAL) << "Failed to open primary graphics card";
-      return;
+  auto it = drm_devices_.find(primary_graphics_card_path_);
+  DCHECK(it != drm_devices_.end());
+  // Send the primary device first since this is used to initialize graphics
+  // state.
+  proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
+      it->first, base::FileDescriptor(it->second->Duplicate())));
+
+  for (auto pair : drm_devices_) {
+    if (pair.second->IsValid() && pair.first != primary_graphics_card_path_) {
+      proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
+          pair.first, base::FileDescriptor(pair.second->Duplicate())));
     }
-    proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
-        primary_graphics_card_path_, base::FileDescriptor(file.Pass())));
   }
 
   device_manager_->ScanDevices(this);
   FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
                     OnConfigurationChanged());
 }
 
 void DrmNativeDisplayDelegate::OnChannelDestroyed(int host_id) {
   // If the channel got destroyed in the middle of a configuration then just
   // respond with failure.
@@ skipping 73 matching lines @@
     set_hdcp_state_callback_map_.erase(it);
   }
 }
 
 void DrmNativeDisplayDelegate::RunUpdateDisplaysCallback(
     const GetDisplaysCallback& callback) const {
   callback.Run(displays_.get());
 }
 
 }  // namespace ui