NotForReview: Implement zero/one-copy texture for ozone freon using Intel DRM

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 <xf86drm.h>
 
 #include "base/files/file_enumerator.h"
 #include "base/posix/eintr_wrapper.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/common/gpu/ozone_gpu_messages.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_gpu_platform_support_host.h"
 #include "ui/ozone/platform/drm/host/drm_native_display_delegate.h"
 
+#include "base/command_line.h"
+#include "ui/ozone/public/ozone_switches.h"
+
 namespace ui {
 
 namespace {
 
 typedef base::Callback<void(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/";
@@ skipping 86 matching lines @@
     // synchronously since the GPU process will need it to initialize the
     // graphics state.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     primary_drm_device_handle_.reset(new DrmDeviceHandle());
     if (!primary_drm_device_handle_->Initialize(primary_graphics_card_path_)) {
       LOG(FATAL) << "Failed to open primary graphics card";
       return;
     }
     drm_devices_.insert(primary_graphics_card_path_);
 
+    int duped_handle = HANDLE_EINTR(dup(primary_drm_device_handle_->GetFD()));
+    if (duped_handle < 0)
+      LOG(FATAL) << "Failed to dup primary graphics card for renderer";
+    primary_drm_device_file_.reset(duped_handle);
+
     vgem_card_path_ = GetVgemCardPath();
     if (!vgem_card_path_.empty()) {
       int fd = HANDLE_EINTR(
           open(vgem_card_path_.value().c_str(), O_RDWR | O_CLOEXEC));
       if (fd < 0) {
         PLOG(ERROR) << "Failed to open vgem: " << vgem_card_path_.value();
       }
       vgem_card_device_file_.reset(fd);
     }
   }
 
   device_manager_->AddObserver(this);
   proxy_->RegisterHandler(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) {
     displays_.push_back(new DrmDisplayHost(
         proxy_, CreateDisplaySnapshotParams(display_infos[i],
                                             primary_drm_device_handle_->fd(), i,
                                             gfx::Point()),
         true /* is_dummy */));
   }
 }
 
 base::FileDescriptor DrmDisplayHostManager::DupVgemFd() {
-  if (vgem_card_path_.empty())
+  int device_fd = vgem_card_device_file_.get();
+  base::FilePath* device_path = &vgem_card_path_;
+
+  bool enable_intel_drm = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kOzoneUseIntelDrm);
+  if (enable_intel_drm) {
+    device_fd = primary_drm_device_file_.get();

[dshwang, 2015/06/29 17:42:07]

When --ozone-use-intel-drm, "/dev/dri/card0" is sent to Renderer, instead of
VGEM fd. This CL didn't rename vgem_fd_ to minimize the changes.

+    device_path = &primary_graphics_card_path_;
+  }
+
+  if (device_path->empty())
     return base::FileDescriptor();
 
   int duped_handle = -1;
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
-    duped_handle = HANDLE_EINTR(dup(vgem_card_device_file_.get()));
+    duped_handle = HANDLE_EINTR(dup(device_fd));
   }
   if (duped_handle < 0) {
     PLOG(ERROR) << "dup() failed.";
     return base::FileDescriptor();
   }
 
   return base::FileDescriptor(duped_handle, true);
 }
 
 DrmDisplayHostManager::~DrmDisplayHostManager() {
@@ skipping 315 matching lines @@
 
   callback.Run(snapshots);
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui