Propagate supported scanout formats from driver to SurfaceFactoryOzone.

ui/ozone/platform/drm/gpu/gbm_surface_factory.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/gpu/gbm_surface_factory.h"
 
 #include <gbm.h>
 
 #include "base/files/file_path.h"
 #include "build/build_config.h"
 #include "third_party/khronos/EGL/egl.h"
 #include "ui/ozone/common/egl_util.h"
+#include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_thread_proxy.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
 #include "ui/ozone/platform/drm/gpu/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surfaceless.h"
 #include "ui/ozone/platform/drm/gpu/proxy_helpers.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
@@ skipping 73 matching lines @@
 }
 
 scoped_ptr<SurfaceOzoneEGL>
 GbmSurfaceFactory::CreateSurfacelessEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return make_scoped_ptr(
       new GbmSurfaceless(drm_thread_->CreateDrmWindowProxy(widget), this));
 }
 
+bool GbmSurfaceFactory::GetSupportedFormats(

[spang, 2016/01/20 18:52:24]

Why does this take a usage parameter?

This is checking formats supported by the display controller, so it's only
relevant for scanout.

It seems like 

  std::vector<gfx::BufferFormat> GetScanoutFormats();

is what you want.

But it's concerning that this API is not parameterized by display device. It'll
break if some secondary device doesn't have all the formats of the primary
device, right?

[william.xie, 2016/01/21 02:14:02]

Thanks Michael, I documented the concern in the API header file to notify the
user be careful for that. 

+    gfx::BufferUsage buffer_usage,
+    std::vector<gfx::BufferFormat>* support_formats) {
+  auto it = support_formats_map_.find(buffer_usage);
+  if (it != support_formats_map_.end()) {
+    *support_formats = it->second;
+    return true;
+  }
+
+  switch (buffer_usage) {
+    case gfx::BufferUsage::SCANOUT:
+      if (drm_thread_ != nullptr) {
+        std::vector<uint32_t> fourcc_formats;
+        drm_thread_->GetSupportedFormats(&fourcc_formats);
+        for (auto& fourcc : fourcc_formats)
+          support_formats->push_back(GetBufferFormatFromFourCCFormat(fourcc));
+        support_formats_map_.insert(
+            std::make_pair(buffer_usage, *support_formats));
+        return true;
+      }
+    default:
+      return false;
+  }
+
+  return false;
+}
+
 scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmap(
     gfx::AcceleratedWidget widget,
     gfx::Size size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
 #if !defined(OS_CHROMEOS)
   // Support for memory mapping accelerated buffers requires some
   // CrOS-specific patches (using vgem).
   DCHECK(gfx::BufferUsage::SCANOUT == usage);
 #endif
@@ skipping 11 matching lines @@
 }
 
 scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmapFromHandle(
     const gfx::NativePixmapHandle& handle) {
   scoped_refptr<GbmPixmap> pixmap(new GbmPixmap(this));
   pixmap->Initialize(base::ScopedFD(handle.fd.fd), handle.stride);
   return pixmap;
 }
 
 }  // namespace ui