ozone: Implement zero/one-copy texture for Ozone GBM.

ui/ozone/platform/drm/common/client_native_pixmap_factory_gbm.cc

 // Copyright 2015 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/common/client_native_pixmap_factory_gbm.h"
 
 #include "base/file_descriptor_posix.h"
 #include "ui/gfx/native_pixmap_handle_ozone.h"
 #include "ui/ozone/public/client_native_pixmap_factory.h"
 
+#if defined(USE_VGEM_MAP)
+#include <fcntl.h>
+#include "ui/ozone/platform/drm/gpu/client_native_pixmap_vgem.h"
+#endif
+
 namespace ui {
 
 namespace {
 
 class ClientNativePixmapGbm : public ClientNativePixmap {
  public:
   ClientNativePixmapGbm() {}
   ~ClientNativePixmapGbm() override {}
 
   bool Map(void** data) override {
     NOTREACHED();
     return false;
   }
   void Unmap() override { NOTREACHED(); }
   void GetStride(int* stride) const override { NOTREACHED(); }
 };
 
 class ClientNativePixmapFactoryGbm : public ClientNativePixmapFactory {
  public:
-  ClientNativePixmapFactoryGbm() {}
+  ClientNativePixmapFactoryGbm() {
+#if defined(USE_VGEM_MAP)
+    // TODO(dshwang): remove ad-hoc file open. crrev.com/1248713002
+    static const char kVgemPath[] = "/dev/dri/renderD129";
+    int vgem_fd = open(kVgemPath, O_RDWR | O_CLOEXEC);
+    vgem_fd_.reset(vgem_fd);
+    DCHECK_GE(vgem_fd_.get(), 0) << "Failed to open: " << kVgemPath;
+#endif
+  }
   ~ClientNativePixmapFactoryGbm() override {}
 
   // ClientNativePixmapFactory:
   std::vector<Configuration> GetSupportedConfigurations() const override {
     const Configuration kConfigurations[] = {
         {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::SCANOUT},
         {gfx::BufferFormat::RGBX_8888, gfx::BufferUsage::SCANOUT}};
     std::vector<Configuration> configurations(
         kConfigurations, kConfigurations + arraysize(kConfigurations));
+#if defined(USE_VGEM_MAP)
+    configurations.push_back(
+        {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::MAP});
+#endif
     return configurations;
   }
   scoped_ptr<ClientNativePixmap> ImportFromHandle(
       const gfx::NativePixmapHandle& handle,
       const gfx::Size& size,
-      gfx::BufferFormat format,
       gfx::BufferUsage usage) override {
+    DCHECK(handle.fd.auto_close);

[reveman, 2015/08/13 14:03:58]

This DCHECK is still inappropriate imo. This function should take ownership of
the fd even if auto_close is false.

[dshwang, 2015/08/13 14:59:02]

Ok, Done.

     base::ScopedFD scoped_fd(handle.fd.fd);
+
+#if defined(USE_VGEM_MAP)
+    if (usage == gfx::BufferUsage::MAP)

[reveman, 2015/08/13 14:03:58]

can we remove this if statement? if we need it then use a switch statement so
we're forced to update this code when adding a new usage mode.

[dshwang, 2015/08/13 14:59:02]

I restored the switch because ClientNativePixmapGbm is better for scanout
buffer.

[reveman, 2015/08/13 15:15:58]

Just curious, why is ClientNativePixmapGbm better for scanout?

[dshwang, 2015/08/13 15:45:28]

ClientNativePixmapVgem imports handle via drmPrimeFDToHandle for nothing. It
consumes little more battery and memory for nothing.

[reveman, 2015/08/13 17:16:43]

Why does it consume more battery? Could you explain the additional memory usage
as we'll need to understand that for proper memory tracing?

Note: future GMB usage on Mac requires both MAP and SCANOUT for the same buffer.
Would be nice if we could just use SCANOUT for this instead of adding a new
SCANOUT_AND_MAP usage mode.

[dshwang, 2015/08/13 18:13:25]

I made you confused by ambiguous reply. What I mean that ClientNativePixmapVgem
call drmPrimeFDToHandle, which calls ioctl system call. This uses CPU, so little
battery is consumed.
Also it makes drm bo handle, which consumed little memory as much as data
structure.

Ozone is fine with merging MAP and SCANOUT. At the time, SCANOUT will just use
ClientNativePixmapVgem.

[dshwang, 2015/08/13 18:22:09]

After rethinking, I'm not sure SCANOUT and MAP is mergable for all platform. In
general, SCANOUT uses x-tiling or no-tiling so that crt can copy line by line.
MAP uses tiling or no-tiling. MacOS propably uses no-tiling for both case.
However, in other platform, SCANOUT can use x-tiling, and MAP can use tiling.
Some platforms restrict tiling buffer from overlaying.
So I think BufferUsage needs to distinguish MAP and SCANOUT in the future also.

+      return ClientNativePixmapVgem::ImportFromDmabuf(
+          vgem_fd_.get(), scoped_fd.get(), size, handle.stride);

[reveman, 2015/08/13 14:03:58]

nit: {} as multiple lines

+#endif
     return make_scoped_ptr<ClientNativePixmapGbm>(new ClientNativePixmapGbm);
   }
 
  private:
+#if defined(USE_VGEM_MAP)
+  base::ScopedFD vgem_fd_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(ClientNativePixmapFactoryGbm);
 };
 
 }  // namespace
 
 ClientNativePixmapFactory* CreateClientNativePixmapFactoryGbm() {
   return new ClientNativePixmapFactoryGbm();
 }
 
 }  // namespace ui