Support for depth renderbuffer attachment.

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"
@@ skipping 442 matching lines @@
     ~SurfaceImage() override;
 
     scoped_refptr<ui::NativePixmap> pixmap_;
   };
 
   ~GLSurfaceOzoneSurfacelessSurfaceImpl() override;
 
   void BindFramebuffer();
   bool CreatePixmaps();
 
+  static const int kBuffers = 2;
   GLuint fbo_;
-  GLuint textures_[2];
+  GLuint textures_[kBuffers];
+  GLuint* rb_depth_;
   scoped_refptr<GLImage> images_[2];
   int current_surface_;
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfacelessSurfaceImpl);
 };
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::SurfaceImage(
     const gfx::Size& size,
     unsigned internalformat)
     : GLImageLinuxDMABuffer(size, internalformat) {
 }
@@ skipping 21 matching lines @@
 GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::~SurfaceImage() {
 }
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::GLSurfaceOzoneSurfacelessSurfaceImpl(
     scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget,
     const gfx::SurfaceConfiguration& requested_configuration)
     : GLSurfaceOzoneSurfaceless(
         ozone_surface.Pass(), widget, requested_configuration),
       fbo_(0),
+      rb_depth_(nullptr),
       current_surface_(0) {
   for (auto& texture : textures_)
     texture = 0;
 }
 
 unsigned int
 GLSurfaceOzoneSurfacelessSurfaceImpl::GetBackingFrameBufferObject() {
   return fbo_;
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::OnMakeCurrent(GLContext* context) {
   if (!fbo_) {
     glGenFramebuffersEXT(1, &fbo_);
     if (!fbo_)
       return false;
     glGenTextures(arraysize(textures_), textures_);
+    if (get_surface_configuration().depth_bits <= 16) {
+      rb_depth_ = new GLuint[kBuffers];
+      glGenRenderbuffersEXT(kBuffers, rb_depth_);
+    }
     if (!CreatePixmaps())
       return false;
   }
   BindFramebuffer();
   glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_);
   return SurfacelessEGL::OnMakeCurrent(context);
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::Resize(const gfx::Size& size) {
   if (size == GetSize())
@@ skipping 32 matching lines @@
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
   GLContext* current_context = GLContext::GetCurrent();
   DCHECK(current_context && current_context->IsCurrent(this));
   glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
   if (fbo_) {
     glDeleteTextures(arraysize(textures_), textures_);
     for (auto& texture : textures_)
       texture = 0;
+    if (rb_depth_) {
+      glDeleteRenderbuffersEXT(kBuffers, rb_depth_);
+      delete rb_depth_;

[jamesr, 2015/09/10 00:38:21]

you called operator new[] so you can't call operator delete to free it, that's
undefined behavior. put this in a scoped_ptr<> or std::unique_ptr<> - they have
specializations for XXX_ptr<T[]> that invoke the correct delete[] operator

[cdotstout, 2015/09/10 18:19:47]

Done.

+      rb_depth_ = nullptr;

[jamesr, 2015/09/10 00:38:21]

a real smart pointer will handle this for you too

[cdotstout, 2015/09/10 18:19:47]

Done.

+    }
     glDeleteFramebuffersEXT(1, &fbo_);
     fbo_ = 0;
   }
   for (auto image : images_) {
     if (image)
       image->Destroy(true);
   }
 }
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::~GLSurfaceOzoneSurfacelessSurfaceImpl() {
   DCHECK(!fbo_);
   for (size_t i = 0; i < arraysize(textures_); i++)
     DCHECK(!textures_[i]) << "texture " << i << " not released";
+  DCHECK(!rb_depth_);
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::BindFramebuffer() {
   ScopedFrameBufferBinder fb(fbo_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             textures_[current_surface_], 0);
+  if (rb_depth_) {
+    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
+      GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb_depth_[current_surface_]);
+  }
 }
 
 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(),
                                  ui::SurfaceFactoryOzone::BGRA_8888,
                                  ui::SurfaceFactoryOzone::SCANOUT);
     if (!pixmap)
       return false;
     scoped_refptr<SurfaceImage> image =
         new SurfaceImage(GetSize(), GL_BGRA_EXT);
     if (!image->Initialize(pixmap, gfx::GpuMemoryBuffer::Format::BGRA_8888))
       return false;
     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;
   }
+  if (rb_depth_) {
+    for (size_t i = 0; i < kBuffers; i++) {
+      glBindRenderbufferEXT(GL_RENDERBUFFER, rb_depth_[i]);
+      glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
+        GetSize().width(), GetSize().height());
+    }
+  }
   return true;
 }
 
 }  // namespace
 
 // static
 bool GLSurface::InitializeOneOffInternal() {
   switch (GetGLImplementation()) {
     case kGLImplementationEGLGLES2:
       if (!GLSurfaceEGL::InitializeOneOff()) {
@@ skipping 119 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx