Add NativeViewGLSurfaceEGL::CommitOverlayPlanes support for Android

ui/gl/gl_surface_egl.cc

 // Copyright (c) 2012 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_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
@@ skipping 665 matching lines @@
     swaps_this_generation_++;
   }
 #endif
 
   if (!eglSwapBuffers(GetDisplay(), surface_)) {
     DVLOG(1) << "eglSwapBuffers failed with error "
              << GetLastEGLErrorString();
     return gfx::SwapResult::SWAP_FAILED;
   }
 
+  if (SupportsCommitOverlayPlanes() && !CommitAndClearPendingOverlays())

[piman, 2015/12/01 01:06:45]

SupportsCommitOverlayPlanes() seems orthogonal to
CommitAndClearPendingOverlays(), I think we should just always
CommitAndClearPendingOverlays() (keeping in mind that the overlay list is likely
empty). If anything just not do it if the list is empty.

It might make sense to move this before the eglSwapBuffers, in case there's an
interaction between it and the set of enabled overlays.

[watk, 2015/12/01 01:55:55]

That makes a lot of sense. Done.

+    return gfx::SwapResult::SWAP_FAILED;
+
   return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::Size NativeViewGLSurfaceEGL::GetSize() {
   EGLint width;
   EGLint height;
   if (!eglQuerySurface(GetDisplay(), surface_, EGL_WIDTH, &width) ||
       !eglQuerySurface(GetDisplay(), surface_, EGL_HEIGHT, &height)) {
     NOTREACHED() << "eglQuerySurface failed with error "
                  << GetLastEGLErrorString();
@@ skipping 49 matching lines @@
 gfx::SwapResult NativeViewGLSurfaceEGL::PostSubBuffer(int x,
                                                       int y,
                                                       int width,
                                                       int height) {
   DCHECK(supports_post_sub_buffer_);
   if (!eglPostSubBufferNV(GetDisplay(), surface_, x, y, width, height)) {
     DVLOG(1) << "eglPostSubBufferNV failed with error "
              << GetLastEGLErrorString();
     return gfx::SwapResult::SWAP_FAILED;
   }
+  if (SupportsCommitOverlayPlanes() && !CommitAndClearPendingOverlays())

[piman, 2015/12/01 01:06:45]

(same here)

[watk, 2015/12/01 01:55:55]

Done.

+    return gfx::SwapResult::SWAP_FAILED;
   return gfx::SwapResult::SWAP_ACK;
 }
 
+bool NativeViewGLSurfaceEGL::SupportsCommitOverlayPlanes() {
+#if defined(OS_ANDROID)
+  return true;
+#else
+  return false;
+#endif
+}
+
+gfx::SwapResult NativeViewGLSurfaceEGL::CommitOverlayPlanes() {
+  DCHECK(SupportsCommitOverlayPlanes());
+  return CommitAndClearPendingOverlays()
+             ? gfx::SwapResult::SWAP_ACK
+             : gfx::SwapResult::SWAP_FAILED;
+}
+
 VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 bool NativeViewGLSurfaceEGL::ScheduleOverlayPlane(int z_order,
                                                   OverlayTransform transform,
                                                   gl::GLImage* image,
                                                   const Rect& bounds_rect,
                                                   const RectF& crop_rect) {
-#if defined(OS_ANDROID)
-  // Overlay planes are used on Android for fullscreen video. The image is
-  // expected to update the plane as soon as possible to display the video frame
-  // chosen for this vsync interval.
-  return image->ScheduleOverlayPlane(window_, z_order, transform, bounds_rect,
-                                     crop_rect);
-#else
+#if !defined(OS_ANDROID)
   NOTIMPLEMENTED();
   return false;
+#else
+  pending_overlays_.push_back(
+      GLSurfaceOverlay(z_order, transform, image, bounds_rect, crop_rect));
+  return true;
 #endif
 }
 
 void NativeViewGLSurfaceEGL::OnSetSwapInterval(int interval) {
   swap_interval_ = interval;
 }
 
 NativeViewGLSurfaceEGL::~NativeViewGLSurfaceEGL() {
   Destroy();
 #if defined(OS_ANDROID)
   if (window_)
     ANativeWindow_release(window_);
 #endif
 }
 
+bool NativeViewGLSurfaceEGL::CommitAndClearPendingOverlays() {
+  bool success = true;
+  for (const auto& overlay : pending_overlays_) {
+    // It's expected that GLImage::ScheduleOverlayPlane will overlay contents on
+    // the screen now.
+    success &= overlay.ScheduleOverlayPlane(window_);
+  }
+  pending_overlays_.clear();
+  return success;
+}
+
 PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(const gfx::Size& size)
     : size_(size),
       surface_(NULL) {
   // Some implementations of Pbuffer do not support having a 0 size. For such
   // cases use a (1, 1) surface.
   if (size_.GetArea() == 0)
     size_.SetSize(1, 1);
 }
 
 bool PbufferGLSurfaceEGL::Initialize() {
@@ skipping 154 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx