Convert Ozone GBM to use new surface API.

ui/gl/init/gl_surface_ozone.cc

 // Copyright 2016 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/init/gl_surface_ozone.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 44 matching lines @@
 
 // Populates EglConfigCallbacks with appropriate callbacks.
 ui::EglConfigCallbacks GetEglConfigCallbacks(EGLDisplay display) {
   ui::EglConfigCallbacks callbacks;
   callbacks.choose_config = base::Bind(EglChooseConfig, display);
   callbacks.get_config_attribute = base::Bind(EglGetConfigAttribute, display);
   callbacks.get_last_error_string = base::Bind(&ui::GetLastEGLErrorString);
   return callbacks;
 }
 
-void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
-  eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
-                       EGL_FOREVER_KHR);
-}
-
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow.
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     gfx::AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize(GLSurface::Format format) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
@@ skipping 95 matching lines @@
 
   window_ = ozone_surface_->GetNativeWindow();
   if (!Initialize(format_)) {
     LOG(ERROR) << "Failed to initialize.";
     return false;
   }
 
   return true;
 }
 
-class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
- public:
-  GLSurfaceOzoneSurfaceless(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-                            gfx::AcceleratedWidget widget);
-
-  // GLSurface:
-  bool Initialize(GLSurface::Format format) override;
-  bool Resize(const gfx::Size& size,
-              float scale_factor,
-              bool has_alpha) override;
-  gfx::SwapResult SwapBuffers() override;
-  bool ScheduleOverlayPlane(int z_order,
-                            gfx::OverlayTransform transform,
-                            GLImage* image,
-                            const gfx::Rect& bounds_rect,
-                            const gfx::RectF& crop_rect) override;
-  bool IsOffscreen() override;
-  gfx::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,
-                          const SwapCompletionCallback& callback) override;
-  EGLConfig GetConfig() override;
-
- protected:
-  struct PendingFrame {
-    PendingFrame();
-
-    bool ScheduleOverlayPlanes(gfx::AcceleratedWidget widget);
-    void Flush();
-
-    bool ready;
-    std::vector<GLSurfaceOverlay> overlays;
-    SwapCompletionCallback callback;
-  };
-
-  ~GLSurfaceOzoneSurfaceless() override;
-
-  void SubmitFrame();
-
-  EGLSyncKHR InsertFence(bool implicit);
-  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.
-  std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
-  gfx::AcceleratedWidget widget_;
-  std::unique_ptr<gfx::VSyncProvider> vsync_provider_;
-  ScopedVector<PendingFrame> unsubmitted_frames_;
-  bool has_implicit_external_sync_;
-  bool has_image_flush_external_;
-  bool last_swap_buffers_result_;
-  bool swap_buffers_pending_;
-
-  base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
-};
-
-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;
-}
-
-void GLSurfaceOzoneSurfaceless::PendingFrame::Flush() {
-  for (const auto& overlay : overlays)
-    overlay.Flush();
-}
-
-GLSurfaceOzoneSurfaceless::GLSurfaceOzoneSurfaceless(
-    std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-    gfx::AcceleratedWidget widget)
-    : SurfacelessEGL(gfx::Size()),
-      ozone_surface_(std::move(ozone_surface)),
-      widget_(widget),
-      has_implicit_external_sync_(
-          HasEGLExtension("EGL_ARM_implicit_external_sync")),
-      has_image_flush_external_(
-          HasEGLExtension("EGL_EXT_image_flush_external")),
-      last_swap_buffers_result_(true),
-      swap_buffers_pending_(false),
-      weak_factory_(this) {
-  unsubmitted_frames_.push_back(new PendingFrame());
-}
-
-bool GLSurfaceOzoneSurfaceless::Initialize(GLSurface::Format format) {
-  if (!SurfacelessEGL::Initialize(format))
-    return false;
-  vsync_provider_ = ozone_surface_->CreateVSyncProvider();
-  if (!vsync_provider_)
-    return false;
-  return true;
-}
-
-bool GLSurfaceOzoneSurfaceless::Resize(const gfx::Size& size,
-                                       float scale_factor,
-                                       bool has_alpha) {
-  if (!ozone_surface_->ResizeNativeWindow(size))
-    return false;
-
-  return SurfacelessEGL::Resize(size, scale_factor, has_alpha);
-}
-
-gfx::SwapResult GLSurfaceOzoneSurfaceless::SwapBuffers() {
-  glFlush();
-
-  unsubmitted_frames_.back()->Flush();
-
-  // TODO: the following should be replaced by a per surface flush as it gets
-  // implemented in GL drivers.
-  if (has_implicit_external_sync_ || has_image_flush_external_) {
-    EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
-    if (!fence)
-      return gfx::SwapResult::SWAP_FAILED;
-
-    EGLDisplay display = GetDisplay();
-    WaitForFence(display, fence);
-    eglDestroySyncKHR(display, fence);
-  }
-
-  unsubmitted_frames_.back()->ScheduleOverlayPlanes(widget_);
-  unsubmitted_frames_.back()->overlays.clear();
-
-  if (ozone_surface_->IsUniversalDisplayLinkDevice())
-    glFinish();
-
-  return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
-                                         : gfx::SwapResult::SWAP_FAILED;
-}
-
-bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(
-    int z_order,
-    gfx::OverlayTransform transform,
-    GLImage* image,
-    const gfx::Rect& bounds_rect,
-    const gfx::RectF& crop_rect) {
-  unsubmitted_frames_.back()->overlays.push_back(
-      GLSurfaceOverlay(z_order, transform, image, bounds_rect, crop_rect));
-  return true;
-}
-
-bool GLSurfaceOzoneSurfaceless::IsOffscreen() {
-  return false;
-}
-
-gfx::VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
-  return vsync_provider_.get();
-}
-
-bool GLSurfaceOzoneSurfaceless::SupportsAsyncSwap() {
-  return true;
-}
-
-bool GLSurfaceOzoneSurfaceless::SupportsPostSubBuffer() {
-  return true;
-}
-
-gfx::SwapResult GLSurfaceOzoneSurfaceless::PostSubBuffer(int x,
-                                                         int y,
-                                                         int width,
-                                                         int height) {
-  // The actual sub buffer handling is handled at higher layers.
-  NOTREACHED();
-  return gfx::SwapResult::SWAP_FAILED;
-}
-
-void GLSurfaceOzoneSurfaceless::SwapBuffersAsync(
-    const SwapCompletionCallback& callback) {
-  // If last swap failed, don't try to schedule new ones.
-  if (!last_swap_buffers_result_) {
-    callback.Run(gfx::SwapResult::SWAP_FAILED);
-    return;
-  }
-
-  glFlush();
-  unsubmitted_frames_.back()->Flush();
-
-  SwapCompletionCallback surface_swap_callback =
-      base::Bind(&GLSurfaceOzoneSurfaceless::SwapCompleted,
-                 weak_factory_.GetWeakPtr(), callback);
-
-  PendingFrame* frame = unsubmitted_frames_.back();
-  frame->callback = surface_swap_callback;
-  unsubmitted_frames_.push_back(new PendingFrame());
-
-  // TODO: the following should be replaced by a per surface flush as it gets
-  // implemented in GL drivers.
-  if (has_implicit_external_sync_ || has_image_flush_external_) {
-    EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
-    if (!fence) {
-      callback.Run(gfx::SwapResult::SWAP_FAILED);
-      return;
-    }
-
-    base::Closure fence_wait_task =
-        base::Bind(&WaitForFence, GetDisplay(), fence);
-
-    base::Closure fence_retired_callback =
-        base::Bind(&GLSurfaceOzoneSurfaceless::FenceRetired,
-                   weak_factory_.GetWeakPtr(), fence, frame);
-
-    base::WorkerPool::PostTaskAndReply(FROM_HERE, fence_wait_task,
-                                       fence_retired_callback, false);
-    return;  // Defer frame submission until fence signals.
-  }
-
-  frame->ready = true;
-  SubmitFrame();
-}
-
-void GLSurfaceOzoneSurfaceless::PostSubBufferAsync(
-    int x,
-    int y,
-    int width,
-    int height,
-    const SwapCompletionCallback& callback) {
-  // The actual sub buffer handling is handled at higher layers.
-  SwapBuffersAsync(callback);
-}
-
-EGLConfig GLSurfaceOzoneSurfaceless::GetConfig() {
-  if (!config_) {
-    ui::EglConfigCallbacks callbacks = GetEglConfigCallbacks(GetDisplay());
-    config_ = ozone_surface_->GetEGLSurfaceConfig(callbacks);
-  }
-  if (config_)
-    return config_;
-  return SurfacelessEGL::GetConfig();
-}
-
-GLSurfaceOzoneSurfaceless::~GLSurfaceOzoneSurfaceless() {
-  Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
-}
-
-void GLSurfaceOzoneSurfaceless::SubmitFrame() {
-  DCHECK(!unsubmitted_frames_.empty());
-
-  if (unsubmitted_frames_.front()->ready && !swap_buffers_pending_) {
-    std::unique_ptr<PendingFrame> frame(unsubmitted_frames_.front());
-    unsubmitted_frames_.weak_erase(unsubmitted_frames_.begin());
-    swap_buffers_pending_ = true;
-
-    if (!frame->ScheduleOverlayPlanes(widget_)) {
-      // |callback| is a wrapper for SwapCompleted(). Call it to properly
-      // propagate the failed state.
-      frame->callback.Run(gfx::SwapResult::SWAP_FAILED);
-      return;
-    }
-
-    if (ozone_surface_->IsUniversalDisplayLinkDevice())
-      glFinish();
-
-    ozone_surface_->OnSwapBuffersAsync(frame->callback);
-  }
-}
-
-EGLSyncKHR GLSurfaceOzoneSurfaceless::InsertFence(bool implicit) {
-  const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
-                                EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
-                                EGL_NONE};
-  return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR,
-                          implicit ? attrib_list : NULL);
-}
-
-void GLSurfaceOzoneSurfaceless::FenceRetired(EGLSyncKHR fence,
-                                             PendingFrame* frame) {
-  eglDestroySyncKHR(GetDisplay(), fence);
-  frame->ready = true;
-  SubmitFrame();
-}
-
-void GLSurfaceOzoneSurfaceless::SwapCompleted(
-    const SwapCompletionCallback& callback,
-    gfx::SwapResult result) {
-  callback.Run(result);
-  swap_buffers_pending_ = false;
-  if (result == gfx::SwapResult::SWAP_FAILED) {
-    last_swap_buffers_result_ = false;
-    return;
-  }
-
-  SubmitFrame();
-}
-
-// This provides surface-like semantics implemented through surfaceless.
-// A framebuffer is bound automatically.
-class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
-    : public GLSurfaceOzoneSurfaceless {
- public:
-  GLSurfaceOzoneSurfacelessSurfaceImpl(
-      std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-      gfx::AcceleratedWidget widget);
-
-  // GLSurface:
-  unsigned int GetBackingFrameBufferObject() override;
-  bool OnMakeCurrent(GLContext* context) override;
-  bool Resize(const gfx::Size& size,
-              float scale_factor,
-              bool has_alpha) override;
-  bool SupportsPostSubBuffer() override;
-  gfx::SwapResult SwapBuffers() override;
-  void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
-  void Destroy() override;
-  bool IsSurfaceless() const override;
-
- private:
-  ~GLSurfaceOzoneSurfacelessSurfaceImpl() override;
-
-  void BindFramebuffer();
-  bool CreatePixmaps();
-
-  scoped_refptr<GLContext> context_;
-  GLuint fbo_;
-  GLuint textures_[2];
-  scoped_refptr<GLImage> images_[2];
-  int current_surface_;
-  DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfacelessSurfaceImpl);
-};
-
-GLSurfaceOzoneSurfacelessSurfaceImpl::GLSurfaceOzoneSurfacelessSurfaceImpl(
-    std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-    gfx::AcceleratedWidget widget)
-    : GLSurfaceOzoneSurfaceless(std::move(ozone_surface), widget),
-      context_(nullptr),
-      fbo_(0),
-      current_surface_(0) {
-  for (auto& texture : textures_)
-    texture = 0;
-}
-
-unsigned int
-GLSurfaceOzoneSurfacelessSurfaceImpl::GetBackingFrameBufferObject() {
-  return fbo_;
-}
-
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::OnMakeCurrent(GLContext* context) {
-  DCHECK(!context_ || context == context_);
-  context_ = context;
-  if (!fbo_) {
-    glGenFramebuffersEXT(1, &fbo_);
-    if (!fbo_)
-      return false;
-    glGenTextures(arraysize(textures_), textures_);
-    if (!CreatePixmaps())
-      return false;
-  }
-  BindFramebuffer();
-  glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_);
-  return SurfacelessEGL::OnMakeCurrent(context);
-}
-
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::Resize(const gfx::Size& size,
-                                                  float scale_factor,
-                                                  bool has_alpha) {
-  if (size == GetSize())
-    return true;
-  // Alpha value isn't actually used in allocating buffers yet, so always use
-  // true instead.
-  return GLSurfaceOzoneSurfaceless::Resize(size, scale_factor, true) &&
-         CreatePixmaps();
-}
-
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::SupportsPostSubBuffer() {
-  return false;
-}
-
-gfx::SwapResult GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffers() {
-  if (!images_[current_surface_]->ScheduleOverlayPlane(
-          widget_, 0, gfx::OverlayTransform::OVERLAY_TRANSFORM_NONE,
-          gfx::Rect(GetSize()), gfx::RectF(1, 1)))
-    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, gfx::OverlayTransform::OVERLAY_TRANSFORM_NONE,
-          gfx::Rect(GetSize()), gfx::RectF(1, 1))) {
-    callback.Run(gfx::SwapResult::SWAP_FAILED);
-    return;
-  }
-  GLSurfaceOzoneSurfaceless::SwapBuffersAsync(callback);
-  current_surface_ ^= 1;
-  BindFramebuffer();
-}
-
-void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
-  if (!context_)
-    return;
-  scoped_refptr<GLContext> previous_context = GLContext::GetCurrent();
-  scoped_refptr<GLSurface> previous_surface;
-
-  bool was_current = previous_context && previous_context->IsCurrent(nullptr) &&
-                     GLSurface::GetCurrent() == this;
-  if (!was_current) {
-    // Only take a reference to previous surface if it's not |this|
-    // because otherwise we can take a self reference from our own dtor.
-    previous_surface = GLSurface::GetCurrent();
-    context_->MakeCurrent(this);
-  }
-
-  glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
-  if (fbo_) {
-    glDeleteTextures(arraysize(textures_), textures_);
-    for (auto& texture : textures_)
-      texture = 0;
-    glDeleteFramebuffersEXT(1, &fbo_);
-    fbo_ = 0;
-  }
-  for (auto image : images_) {
-    if (image)
-      image->Destroy(true);
-  }
-
-  if (!was_current) {
-    if (previous_context) {
-      previous_context->MakeCurrent(previous_surface.get());
-    } else {
-      context_->ReleaseCurrent(this);
-    }
-  }
-}
-
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::IsSurfaceless() const {
-  return false;
-}
-
-GLSurfaceOzoneSurfacelessSurfaceImpl::~GLSurfaceOzoneSurfacelessSurfaceImpl() {
-  Destroy();
-}
-
-void GLSurfaceOzoneSurfacelessSurfaceImpl::BindFramebuffer() {
-  ScopedFrameBufferBinder fb(fbo_);
-  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                            textures_[current_surface_], 0);
-}
-
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::CreatePixmaps() {
-  if (!fbo_)
-    return true;
-  for (size_t i = 0; i < arraysize(textures_); i++) {
-    scoped_refptr<ui::NativePixmap> pixmap =
-        ui::OzonePlatform::GetInstance()
-            ->GetSurfaceFactoryOzone()
-            ->CreateNativePixmap(widget_, GetSize(),
-                                 gfx::BufferFormat::BGRA_8888,
-                                 gfx::BufferUsage::SCANOUT);
-    if (!pixmap)
-      return false;
-    scoped_refptr<ui::GLImageOzoneNativePixmap> image =
-        new ui::GLImageOzoneNativePixmap(GetSize(), GL_BGRA_EXT);
-    if (!image->Initialize(pixmap.get(), gfx::BufferFormat::BGRA_8888))
-      return false;
-    // Image must have Destroy() called before destruction.
-    if (images_[i])
-      images_[i]->Destroy(true);
-    images_[i] = image;
-    // Bind image to texture.
-    ScopedTextureBinder binder(GL_TEXTURE_2D, textures_[i]);
-    if (!images_[i]->BindTexImage(GL_TEXTURE_2D))
-      return false;
-  }
-  return true;
-}
-
 }  // namespace
 
 scoped_refptr<GLSurface> CreateViewGLSurfaceOzone(
     gfx::AcceleratedWidget window) {
   std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
       ui::OzonePlatform::GetInstance()
           ->GetSurfaceFactoryOzone()
           ->CreateEGLSurfaceForWidget(window);
   if (!surface_ozone)
     return nullptr;
   return InitializeGLSurface(
       new GLSurfaceOzoneEGL(std::move(surface_ozone), window));
 }
 
-scoped_refptr<GLSurface> CreateViewGLSurfaceOzoneSurfaceless(
-    gfx::AcceleratedWidget window) {
-  std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-      ui::OzonePlatform::GetInstance()
-          ->GetSurfaceFactoryOzone()
-          ->CreateSurfacelessEGLSurfaceForWidget(window);
-  if (!surface_ozone)
-    return nullptr;
-  return InitializeGLSurface(
-      new GLSurfaceOzoneSurfaceless(std::move(surface_ozone), window));
-}
-
-scoped_refptr<GLSurface> CreateViewGLSurfaceOzoneSurfacelessSurfaceImpl(
-    gfx::AcceleratedWidget window) {
-  std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-      ui::OzonePlatform::GetInstance()
-          ->GetSurfaceFactoryOzone()
-          ->CreateSurfacelessEGLSurfaceForWidget(window);
-  if (!surface_ozone)
-    return nullptr;
-  return InitializeGLSurface(new GLSurfaceOzoneSurfacelessSurfaceImpl(
-      std::move(surface_ozone), window));
-}
-
 }  // namespace gl