Add support to send optimal format as part of ScheduleOverlayPlane

ui/gl/gl_surface_ozone.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/gl/gl_surface.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 33 matching lines @@
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize() override;
   bool Resize(const gfx::Size& size, float scale_factor) override;
   gfx::SwapResult SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
+                            gfx::BufferFormat storage_format,
                             GLImage* image,
                             const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            const RectF& crop_rect,
+                            bool handle_scaling) override;
 
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
   ~GLSurfaceOzoneEGL() override;
 
   bool ReinitializeNativeSurface();
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
@@ skipping 27 matching lines @@
   gfx::SwapResult result = NativeViewGLSurfaceEGL::SwapBuffers();
   if (result != gfx::SwapResult::SWAP_ACK)
     return result;
 
   return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
 bool GLSurfaceOzoneEGL::ScheduleOverlayPlane(int z_order,
                                              OverlayTransform transform,
+                                             gfx::BufferFormat storage_format,
                                              GLImage* image,
                                              const Rect& bounds_rect,
-                                             const RectF& crop_rect) {
-  return image->ScheduleOverlayPlane(widget_, z_order, transform, bounds_rect,
-                                     crop_rect);
+                                             const RectF& crop_rect,
+                                             bool handle_scaling) {
+  return image->ScheduleOverlayPlane(widget_, z_order, transform,
+                                     storage_format, bounds_rect,
+                                     crop_rect, handle_scaling);
 }
 
 GLSurfaceOzoneEGL::~GLSurfaceOzoneEGL() {
   Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
 bool GLSurfaceOzoneEGL::ReinitializeNativeSurface() {
   scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
   GLContext* current_context = GLContext::GetCurrent();
   bool was_current = current_context && current_context->IsCurrent(this);
@@ skipping 23 matching lines @@
  public:
   GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize() override;
   bool Resize(const gfx::Size& size, float scale_factor) override;
   gfx::SwapResult SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
+                            gfx::BufferFormat storage_format,
                             GLImage* image,
                             const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            const RectF& crop_rect,
+                            bool handle_scaling) override;
   bool IsOffscreen() override;
   VSyncProvider* GetVSyncProvider() override;
   bool SupportsAsyncSwap() override;
   bool SupportsPostSubBuffer() override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
@@ skipping 91 matching lines @@
     glFinish();
   }
 
   unsubmitted_frames_.back()->ScheduleOverlayPlanes(widget_);
   unsubmitted_frames_.back()->overlays.clear();
 
   return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
-bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(int z_order,
-                                                     OverlayTransform transform,
-                                                     GLImage* image,
-                                                     const Rect& bounds_rect,
-                                                     const RectF& crop_rect) {
+bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(
+    int z_order, OverlayTransform transform,
+    gfx::BufferFormat storage_format, GLImage* image,
+    const Rect& bounds_rect, const RectF& crop_rect,
+    bool handle_scaling) {
   unsubmitted_frames_.back()->overlays.push_back(
-      GLSurfaceOverlay(z_order, transform, image, bounds_rect, crop_rect));
+      GLSurfaceOverlay(z_order, transform, storage_format, image, bounds_rect,
+                       crop_rect, handle_scaling));
   return true;
 }
 
 bool GLSurfaceOzoneSurfaceless::IsOffscreen() {
   return false;
 }
 
 VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
   return vsync_provider_.get();
 }
@@ skipping 194 matching lines @@
          CreatePixmaps();
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::SupportsPostSubBuffer() {
   return false;
 }
 
 gfx::SwapResult GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffers() {
   if (!images_[current_surface_]->ScheduleOverlayPlane(
           widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
-          gfx::Rect(GetSize()), gfx::RectF(1, 1)))
+          gfx::BufferFormat::BGRX_8888, gfx::Rect(GetSize()),
+          gfx::RectF(1, 1), true)) {
     return gfx::SwapResult::SWAP_FAILED;
+  }
   gfx::SwapResult result = GLSurfaceOzoneSurfaceless::SwapBuffers();
   if (result != gfx::SwapResult::SWAP_ACK)
     return result;
   current_surface_ ^= 1;
   BindFramebuffer();
   return gfx::SwapResult::SWAP_ACK;
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffersAsync(
     const SwapCompletionCallback& callback) {
   if (!images_[current_surface_]->ScheduleOverlayPlane(
           widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
-          gfx::Rect(GetSize()), gfx::RectF(1, 1))) {
+          gfx::BufferFormat::BGRX_8888, gfx::Rect(GetSize()),
+          gfx::RectF(1, 1), true)) {
     callback.Run(gfx::SwapResult::SWAP_FAILED);
     return;
   }
   GLSurfaceOzoneSurfaceless::SwapBuffersAsync(callback);
   current_surface_ ^= 1;
   BindFramebuffer();
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
   if (!context_)
@@ skipping 189 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx