Ozone: Dont hardcode format to YUV when using Overlay Composition.

ui/ozone/platform/drm/gpu/gbm_surfaceless.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_surfaceless.h"
 
+#include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_vsync_provider.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 
 namespace ui {
 
 GbmSurfaceless::GbmSurfaceless(scoped_ptr<DrmWindowProxy> window,
                                GbmSurfaceFactory* surface_manager)
-    : window_(window.Pass()), surface_manager_(surface_manager) {
+    : window_(window.Pass()),
+      surface_manager_(surface_manager),
+      weak_ptr_factory_(this) {
   surface_manager_->RegisterSurface(window_->widget(), this);
 }
 
 GbmSurfaceless::~GbmSurfaceless() {
   surface_manager_->UnregisterSurface(window_->widget());
 }
 
 void GbmSurfaceless::QueueOverlayPlane(const OverlayPlane& plane) {
   planes_.push_back(plane);
 }
 
+void GbmSurfaceless::EvaluateBufferConfiguration(
+    const gfx::Rect& display_rect,
+    const gfx::RectF& crop_rect,
+    const gfx::Size& buffer_size,
+    gfx::BufferFormat buffer_format,
+    gfx::OverlayTransform transform,
+    uint32_t z_order,
+    gfx::Size* target_size,
+    gfx::BufferFormat* target_format) {
+  OverlayCheck_Params lookup;
+  lookup.display_rect = display_rect;
+  lookup.crop_rect = crop_rect;
+  lookup.buffer_size = buffer_size;
+  lookup.format = buffer_format;
+  lookup.plane_z_order = z_order;
+  lookup.transform = transform;
+
+  std::vector<OverlayCheck_Params>::iterator it;
+  it = std::find(overlay_params_.begin(), overlay_params_.end(), lookup);
+  if (it != overlay_params_.end()) {
+    *target_size = it->required_buffer_size;
+    *target_format = it->optimal_format;
+  } else {
+    *target_size = buffer_size;
+    *target_format = buffer_format;
+  }
+}
+
+void GbmSurfaceless::GetOverlayBufferConfigurations(
+    const std::vector<OverlayCheck_Params>& params) {
+  overlay_params_ = params;
+}
+
 intptr_t GbmSurfaceless::GetNativeWindow() {
   NOTREACHED();
   return 0;
 }
 
 bool GbmSurfaceless::ResizeNativeWindow(const gfx::Size& viewport_size) {
   return true;
 }
 
 bool GbmSurfaceless::OnSwapBuffers() {
   NOTREACHED();
   return false;
 }
 
 void GbmSurfaceless::OnSwapBuffersAsync(
     const SwapCompletionCallback& callback) {
+  window_->GetOverlayBufferConfigurations(

[kalyank, 2015/11/19 16:10:41]

I am still looking if we can pass target size and format as part of
ScheduleOverlayPlane. This would avoid the need for the callback.

+      base::Bind(&GbmSurfaceless::GetOverlayBufferConfigurations,
+                 weak_ptr_factory_.GetWeakPtr()));
+
   window_->SchedulePageFlip(planes_, callback);
   planes_.clear();
 }
 
 scoped_ptr<gfx::VSyncProvider> GbmSurfaceless::CreateVSyncProvider() {
   return make_scoped_ptr(new DrmVSyncProvider(window_.get()));
 }
 
 bool GbmSurfaceless::IsUniversalDisplayLinkDevice() {
   return planes_.empty() ? false : planes_[0].buffer->RequiresGlFinish();
 }
 
 }  // namespace ui