ozone: Create RGBX (not RGBA) buffers in GbmSurface.

ui/ozone/platform/drm/gpu/gbm_surface.cc

 // Copyright 2016 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/gbm_surface.h"
 
 #include <utility>
 
 #include "base/logging.h"
+#include "ui/display/types/display_snapshot.h"
 #include "ui/gfx/native_pixmap.h"
 #include "ui/gl/gl_image_native_pixmap.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
 
 namespace ui {
 
 GbmSurface::GbmSurface(GbmSurfaceFactory* surface_factory,
                        std::unique_ptr<DrmWindowProxy> window,
@@ skipping 96 matching lines @@
   gl::ScopedFramebufferBinder fb(fbo_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             textures_[current_surface_], 0);
 }
 
 bool GbmSurface::CreatePixmaps() {
   if (!fbo_)
     return true;
   for (size_t i = 0; i < arraysize(textures_); i++) {
     scoped_refptr<gfx::NativePixmap> pixmap =
-        surface_factory()->CreateNativePixmap(widget(), GetSize(),
-                                              gfx::BufferFormat::BGRA_8888,
-                                              gfx::BufferUsage::SCANOUT);
+        surface_factory()->CreateNativePixmap(
+            widget(), GetSize(), display::DisplaySnapshot::PrimaryFormat(),
+            gfx::BufferUsage::SCANOUT);
     if (!pixmap)
       return false;
     scoped_refptr<gl::GLImageNativePixmap> image =
-        new gl::GLImageNativePixmap(GetSize(), GL_BGRA_EXT);
-    if (!image->Initialize(pixmap.get(), gfx::BufferFormat::BGRA_8888))
+        new gl::GLImageNativePixmap(GetSize(), GL_RGB);

[dnicoara, 2017/04/19 14:31:09]

Why is this GL_RGB? Wouldn't this mean a pixel with only 3 components? (vs 4 in
the Bufferformat::BGRX_8888)

[Daniele Castagna, 2017/04/19 14:51:06]

That's the internal pixel format, it doesn't need to match the number of
channels of the buffer format.

In practice, we just use it for validation, take a look at ValidInternalFormat
in gl_image_native_pixmap.cc

[dnicoara, 2017/04/19 15:08:23]

Yeah, I saw that and it also confused me. So, what's the relationship between
the 2 then? It seems highly confusing as I expected GL_RGB to be used in GL
operations. Or at the very least I expected BufferFormat to be converted to a
GL_* format at some point.

Should this at the very least use something like
GLImageNativePixmap::GetInternalFormatForTesting()?

+    if (!image->Initialize(pixmap.get(),
+                           display::DisplaySnapshot::PrimaryFormat()))
       return false;
     images_[i] = image;
     // Bind image to texture.
     gl::ScopedTextureBinder binder(GL_TEXTURE_2D, textures_[i]);
     if (!images_[i]->BindTexImage(GL_TEXTURE_2D))
       return false;
   }
   return true;
 }
 
 }  // namespace ui