Add NativeViewGLSurfaceEGL::CommitOverlayPlanes support for Android

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"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/worker_pool.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_image_ozone_native_pixmap.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
+#include "ui/gl/gl_surface_overlay.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
 using gl::GLImage;
 
@@ skipping 125 matching lines @@
   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,
                           const SwapCompletionCallback& callback) override;
 
  protected:
-  struct Overlay {
-    Overlay(int z_order,
-            OverlayTransform transform,
-            GLImage* image,
-            const Rect& bounds_rect,
-            const RectF& crop_rect);
-
-    bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget) const;
-
-    int z_order;
-    OverlayTransform transform;
-    scoped_refptr<GLImage> image;
-    Rect bounds_rect;
-    RectF crop_rect;
-  };
-
   struct PendingFrame {
     PendingFrame();
 
     bool ScheduleOverlayPlanes(gfx::AcceleratedWidget widget);
 
     bool ready;
-    std::vector<Overlay> overlays;
+    std::vector<GLSurfaceOverlay> overlays;
     SwapCompletionCallback callback;
   };
 
   ~GLSurfaceOzoneSurfaceless() override;
 
   void SubmitFrame();
 
   EGLSyncKHR InsertFence();
   void FenceRetired(EGLSyncKHR fence, PendingFrame* frame);
 
   void SwapCompleted(const SwapCompletionCallback& callback,
                      gfx::SwapResult result);
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
   scoped_ptr<VSyncProvider> vsync_provider_;
   ScopedVector<PendingFrame> unsubmitted_frames_;
   bool has_implicit_external_sync_;
   bool last_swap_buffers_result_;
   bool swap_buffers_pending_;
 
   base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
 
-GLSurfaceOzoneSurfaceless::Overlay::Overlay(int z_order,
-                                            OverlayTransform transform,
-                                            GLImage* image,
-                                            const Rect& bounds_rect,
-                                            const RectF& crop_rect)
-    : z_order(z_order),
-      transform(transform),
-      image(image),
-      bounds_rect(bounds_rect),
-      crop_rect(crop_rect) {}
-
-bool GLSurfaceOzoneSurfaceless::Overlay::ScheduleOverlayPlane(
-    gfx::AcceleratedWidget widget) const {
-  return image->ScheduleOverlayPlane(widget, z_order, transform, bounds_rect,
-                                     crop_rect);
-}
-
 GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {}
 
 bool GLSurfaceOzoneSurfaceless::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
   for (const auto& overlay : overlays)
     if (!overlay.ScheduleOverlayPlane(widget))
       return false;
   return true;
 }
 
@@ skipping 50 matching lines @@
   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) {
   unsubmitted_frames_.back()->overlays.push_back(
-      Overlay(z_order, transform, image, bounds_rect, crop_rect));
+      GLSurfaceOverlay(z_order, transform, image, bounds_rect, crop_rect));
   return true;
 }
 
 bool GLSurfaceOzoneSurfaceless::IsOffscreen() {
   return false;
 }
 
 VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
   return vsync_provider_.get();
 }
@@ skipping 418 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx