native_viewport support for ozone

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 233 matching lines @@
   for (const auto& overlay : overlays)
     if (!overlay.ScheduleOverlayPlane(widget))
       return false;
   return true;
 }
 
 GLSurfaceOzoneSurfaceless::GLSurfaceOzoneSurfaceless(
     scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget,
     const gfx::SurfaceConfiguration& requested_configuration)
-    : SurfacelessEGL(gfx::Size(), requested_configuration),
+    : SurfacelessEGL(gfx::Size(1, 1),  // passing zero size causes a failure

[jamesr, 2015/08/25 00:30:28]

:(. is the failure in something we control?

[cdotstout, 2015/08/27 19:10:21]

No, it's gbm/mesa.  Could move the workaround down closer to the if you prefer.

+                     requested_configuration),
       ozone_surface_(ozone_surface.Pass()),
       widget_(widget),
       has_implicit_external_sync_(
           HasEGLExtension("EGL_ARM_implicit_external_sync")),
       last_swap_buffers_result_(true),
       swap_buffers_pending_(false),
       weak_factory_(this) {
   unsubmitted_frames_.push_back(new PendingFrame());
 }
 
@@ skipping 161 matching lines @@
       const gfx::SurfaceConfiguration& requested_configuration);
 
   // GLSurface:
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool Resize(const gfx::Size& size) override;
   bool SupportsPostSubBuffer() override;
   gfx::SwapResult SwapBuffers() override;
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void Destroy() override;
+  bool IsSurfaceless() const override { return false; }
 
  private:
   class SurfaceImage : public GLImageLinuxDMABuffer {
    public:
     SurfaceImage(const gfx::Size& size, unsigned internalformat);
 
     bool Initialize(scoped_refptr<ui::NativePixmap> pixmap,
                     gfx::GpuMemoryBuffer::Format format);
     bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                               int z_order,
@@ skipping 153 matching lines @@
             ->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;
   }
   return true;
 }
 
 }  // namespace
 
 // static
 bool GLSurface::InitializeOneOffInternal() {
@@ skipping 122 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx