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 659 matching lines @@
     } else if (vsync_override_) {
       // Only one window swapping, so let the normal vsync setting take over
       eglSwapInterval(GetDisplay(), swap_interval_);
       vsync_override_ = false;
     }
 
     swaps_this_generation_++;
   }
 #endif
 
+  if (!CommitAndClearPendingOverlays()) {
+    DVLOG(1) << "Failed to commit pending overlay planes.";
+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
   if (!eglSwapBuffers(GetDisplay(), surface_)) {
     DVLOG(1) << "eglSwapBuffers failed with error "
              << GetLastEGLErrorString();
     return gfx::SwapResult::SWAP_FAILED;
   }
 
   return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::Size NativeViewGLSurfaceEGL::GetSize() {
@@ skipping 50 matching lines @@
 
 bool NativeViewGLSurfaceEGL::SupportsPostSubBuffer() {
   return supports_post_sub_buffer_;
 }
 
 gfx::SwapResult NativeViewGLSurfaceEGL::PostSubBuffer(int x,
                                                       int y,
                                                       int width,
                                                       int height) {
   DCHECK(supports_post_sub_buffer_);
+  if (!CommitAndClearPendingOverlays()) {
+    DVLOG(1) << "Failed to commit pending overlay planes.";
+    return gfx::SwapResult::SWAP_FAILED;
+  }
   if (!eglPostSubBufferNV(GetDisplay(), surface_, x, y, width, height)) {
     DVLOG(1) << "eglPostSubBufferNV failed with error "
              << GetLastEGLErrorString();
     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() {
+  if (pending_overlays_.empty())
+    return true;
+
+  bool success = true;
+  for (const auto& overlay : pending_overlays_) {
+    // In general |GLSurfaceOverlay::ScheduleOverlayPlane| only schedules the
+    // overlay to be shown at swap time, but here we assume that the overlays
+    // scheduled on this surface will display themselves to the screen right
+    // away.

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

How do you feel about this? It's not obvious how to make this more consistent
and less subtle.

[piman, 2015/12/01 02:03:02]

I'd move this comment to the CommitOverlayPlanes implementation. That's the
place where it assumes that the overlays will magically appear, and the place
where possibly platform-specific bits would have to "kick" them for truly atomic
changes.

+    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