[8/8][Ozone-Dri] Pass DRM FD to GPU process on hotplug event

ui/ozone/platform/dri/native_display_delegate_proxy.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/dri/native_display_delegate_proxy.h"
 
 #include <stdio.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/dri/display_manager.h"
 #include "ui/ozone/platform/dri/dri_gpu_platform_support_host.h"
 
 namespace ui {
 
 namespace {
 
+const char kDefaultGraphicsCardPath[] = "/dev/dri/card0";

[spang, 2015/02/11 21:13:21]

When do we get to remove this?

[dnicoara, 2015/02/11 22:21:14]

I left a comment in NDDProxy::OnDeviceEvent() on this. The answer would be when
the render nodes patch is upstreamed in the DRM Mesa platform or when we don't
care about backwards compatibility anymore.

+
+typedef base::Callback<void(const base::FilePath&, base::File)>
+    OnOpenDeviceReplyCallback;
+
+void OpenDeviceOnWorkerThread(
+    const base::FilePath& path,
+    const scoped_refptr<base::TaskRunner>& reply_runner,
+    const OnOpenDeviceReplyCallback& callback) {
+  base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ |
+                            base::File::FLAG_WRITE);
+
+  if (file.IsValid()) {
+    reply_runner->PostTask(
+        FROM_HERE, base::Bind(callback, path, base::Passed(file.Pass())));
+  }
+}
+
 class DriDisplaySnapshotProxy : public DisplaySnapshotProxy {
  public:
   DriDisplaySnapshotProxy(const DisplaySnapshot_Params& params,
                           DisplayManager* display_manager)
       : DisplaySnapshotProxy(params), display_manager_(display_manager) {
     display_manager_->RegisterDisplay(this);
   }
 
   ~DriDisplaySnapshotProxy() override {
     display_manager_->UnregisterDisplay(this);
   }
 
  private:
   DisplayManager* display_manager_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(DriDisplaySnapshotProxy);
 };
 
 }  // namespace
 
 NativeDisplayDelegateProxy::NativeDisplayDelegateProxy(
     DriGpuPlatformSupportHost* proxy,
     DeviceManager* device_manager,
     DisplayManager* display_manager)
     : proxy_(proxy),
       device_manager_(device_manager),
       display_manager_(display_manager),
-      has_dummy_display_(false) {
+      has_dummy_display_(false),
+      weak_ptr_factory_(this) {
   proxy_->RegisterHandler(this);
 }
 
 NativeDisplayDelegateProxy::~NativeDisplayDelegateProxy() {
   device_manager_->RemoveObserver(this);
   proxy_->UnregisterHandler(this);
 }
 
 void NativeDisplayDelegateProxy::Initialize() {
   device_manager_->AddObserver(this);
@@ skipping 125 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void NativeDisplayDelegateProxy::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::DISPLAY)
     return;
 
   switch (event.action_type()) {
     case DeviceEvent::ADD:
       VLOG(1) << "Got display added event for " << event.path().value();
-      proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(event.path()));
-      break;
+      // The default card is a special case since it needs to be opened early on
+      // the GPU process in order to initialize EGL. If it is opened here as
+      // well, it will cause a race with opening it in the GPU process and the
+      // GPU process may fail initialization.
+      // TODO(dnicoara) Remove this when EGL_DEFAULT_DISPLAY is the only native
+      // display we return in GbmSurfaceFactory.
+      if (event.path().value() == kDefaultGraphicsCardPath)
+        return;
+
+      base::WorkerPool::PostTask(
+          FROM_HERE,
+          base::Bind(
+              &OpenDeviceOnWorkerThread, event.path(),
+              base::ThreadTaskRunnerHandle::Get(),
+              base::Bind(&NativeDisplayDelegateProxy::OnNewGraphicsDevice,
+                         weak_ptr_factory_.GetWeakPtr())),
+          true /* task_is_slow */);

[spang, 2015/02/11 21:13:21]

Apparently task_is_slow = false should be used unless it's really, really slow
and needs a thread all to itself.

[dnicoara, 2015/02/11 22:21:14]

Done.

+      return;
     case DeviceEvent::CHANGE:
       VLOG(1) << "Got display changed event for " << event.path().value();
       break;
     case DeviceEvent::REMOVE:
       VLOG(1) << "Got display removed event for " << event.path().value();
+      // It shouldn't be possible to remove this device.
+      DCHECK_NE(kDefaultGraphicsCardPath, event.path().value());
       proxy_->Send(new OzoneGpuMsg_RemoveGraphicsDevice(event.path()));
       break;
   }
 
   FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
                     OnConfigurationChanged());
 }
 
+void NativeDisplayDelegateProxy::OnNewGraphicsDevice(const base::FilePath& path,
+                                                     base::File file) {
+  DCHECK(file.IsValid());
+  proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
+      path, base::FileDescriptor(file.Pass())));
+
+  FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
+                    OnConfigurationChanged());
+}
+
 void NativeDisplayDelegateProxy::OnChannelEstablished(
     int host_id,
     scoped_refptr<base::SingleThreadTaskRunner> send_runner,
     const base::Callback<void(IPC::Message*)>& send_callback) {
+  device_manager_->ScanDevices(this);
   FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
                     OnConfigurationChanged());
 }
 
 void NativeDisplayDelegateProxy::OnChannelDestroyed(int host_id) {
   // If the channel got destroyed in the middle of a configuration then just
   // respond with failure.
   if (!get_displays_callback_.is_null()) {
     get_displays_callback_.Run(std::vector<DisplaySnapshot*>());
     get_displays_callback_.Reset();
@@ skipping 36 matching lines @@
 void NativeDisplayDelegateProxy::OnDisplayConfigured(int64_t display_id,
                                                      bool status) {
   auto it = configure_callback_map_.find(display_id);
   if (it != configure_callback_map_.end()) {
     it->second.Run(status);
     configure_callback_map_.erase(it);
   }
 }
 
 }  // namespace ui