[Ozone-Demo] Add support for NativeDisplayDelegate

ui/ozone/demo/surfaceless_gl_renderer.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/ozone/demo/surfaceless_gl_renderer.h"
 
 #include "base/bind.h"
 #include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
 
 namespace ui {
 
 SurfacelessGlRenderer::BufferWrapper::BufferWrapper()
     : widget_(gfx::kNullAcceleratedWidget), gl_fb_(0), gl_tex_(0) {
 }
 
 SurfacelessGlRenderer::BufferWrapper::~BufferWrapper() {
   if (gl_fb_)
     glDeleteFramebuffersEXT(1, &gl_fb_);
@@ skipping 49 matching lines @@
 
 void SurfacelessGlRenderer::BufferWrapper::BindFramebuffer() {
   glBindFramebufferEXT(GL_FRAMEBUFFER, gl_fb_);
 }
 
 void SurfacelessGlRenderer::BufferWrapper::SchedulePlane() {
   image_->ScheduleOverlayPlane(widget_, 0, gfx::OVERLAY_TRANSFORM_NONE,
                                gfx::Rect(size_), gfx::RectF(0, 0, 1, 1));
 }
 
-SurfacelessGlRenderer::SurfacelessGlRenderer(gfx::AcceleratedWidget widget,
-                                             const gfx::Size& size)
+SurfacelessGlRenderer::SurfacelessGlRenderer(
+    gfx::AcceleratedWidget widget,
+    const gfx::Size& size,
+    GpuMemoryBufferFactoryOzoneNativeBuffer* buffer_factory)
     : GlRenderer(widget, size),
+      buffer_factory_(buffer_factory),
       back_buffer_(0),
       is_swapping_buffers_(false),
       weak_ptr_factory_(this) {
 }
 
 SurfacelessGlRenderer::~SurfacelessGlRenderer() {
+  // Need to make current when deleting the framebuffer resources allocated in
+  // the buffers.
+  context_->MakeCurrent(surface_.get());
 }
 
 bool SurfacelessGlRenderer::Initialize() {
   if (!GlRenderer::Initialize())
     return false;
 
   for (size_t i = 0; i < arraysize(buffers_); ++i)
-    if (!buffers_[i].Initialize(&buffer_factory_, widget_, size_))
+    if (!buffers_[i].Initialize(buffer_factory_, widget_, size_))
       return false;
 
   return true;
 }
 
 void SurfacelessGlRenderer::RenderFrame() {
   if (is_swapping_buffers_)
     return;
 
   float fraction = NextFraction();
 
+  context_->MakeCurrent(surface_.get());
   buffers_[back_buffer_].BindFramebuffer();
 
   glViewport(0, 0, size_.width(), size_.height());
   glClearColor(1 - fraction, fraction, 0.0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
   buffers_[back_buffer_].SchedulePlane();
   is_swapping_buffers_ = true;
   if (!surface_->SwapBuffersAsync(
           base::Bind(&SurfacelessGlRenderer::OnSwapBuffersAck,
                      weak_ptr_factory_.GetWeakPtr())))
     LOG(FATAL) << "Failed to swap buffers";
 }
 
 void SurfacelessGlRenderer::OnSwapBuffersAck() {
   is_swapping_buffers_ = false;
   back_buffer_ ^= 1;
 }
 
 }  // namespace ui