Ozone X11 platform

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/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "ui/gfx/native_widget_types.h"
+#include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_make_current.h"
+#include "ui/ozone/public/ozone_switches.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
+using ui::GetLastEGLErrorString;
+
 namespace gfx {
 
 namespace {
 
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget)
       : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
@@ skipping 19 matching lines @@
     return ozone_surface_->OnSwapBuffers();
   }
   virtual bool ScheduleOverlayPlane(int z_order,
                                     OverlayTransform transform,
                                     GLImage* image,
                                     const Rect& bounds_rect,
                                     const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
+  virtual bool SupportsPostSubBuffer() override {
+    return NativeViewGLSurfaceEGL::SupportsPostSubBuffer() &&
+           ozone_surface_->SupportsPartialSwap();
+  }
+
+  EGLConfig GetConfig() override {
+    if (!config_) {

[spang, 2014/12/06 00:31:23]

We may want to delegate this whole config-choosing process and remove
GetEGLSurfaceProperties. It's clearly platform-specific in nontrivial ways.

[achaulk, 2014/12/08 16:44:41]

It is, but it involves calling egl from within ozone, and I thought we were
avoiding that?

[spang, 2014/12/09 19:47:33]

We were mostly worried about #incuding chrome's version of the khronos headers
from ui/ozone/public/*.h because some platforms may need a modified header.

Since EGLConfig is just void* we could still do

class SurfaceOzoneEGL {
  virtual void* /* EGLConfig */ GetConfig() = 0;
};

We don't need to #include any headers for that.

It's definitely ugly but should work.. its a pain that EGL has these
platform-specific typedefs..

+      // Try matching the window depth with an alpha channel,
+      // because we're worried the destination alpha width could
+      // constrain blending precision.
+      const int kBufferSizeOffset = 1;
+      const int kAlphaSizeOffset = 3;
+      EGLint config_attribs[] = {EGL_BUFFER_SIZE,
+                                 ~0,

[spang, 2014/12/06 00:31:23]

I think this was overridden in the old code? Probably not legal to pass ~0.

[achaulk, 2014/12/08 16:44:41]

It's not, but GetEGLSurfaceProperties is doing the replacement

+                                 EGL_ALPHA_SIZE,
+                                 8,
+                                 EGL_BLUE_SIZE,
+                                 8,
+                                 EGL_GREEN_SIZE,
+                                 8,
+                                 EGL_RED_SIZE,
+                                 8,
+                                 EGL_RENDERABLE_TYPE,
+                                 EGL_OPENGL_ES2_BIT,
+                                 EGL_SURFACE_TYPE,
+                                 EGL_WINDOW_BIT,
+                                 EGL_NONE};
+      const int32* chosen_attribs =
+          ui::SurfaceFactoryOzone::GetInstance()->GetEGLSurfaceProperties(
+              config_attribs, ozone_surface_.get());
+
+      EGLint num_configs;
+      if (!eglChooseConfig(GetDisplay(), chosen_attribs, &config_, 1,
+                           &num_configs)) {
+        LOG(ERROR) << "eglChooseConfig failed with error "
+                   << GetLastEGLErrorString();
+        return NULL;
+      }
+
+      if (num_configs) {
+        EGLint config_depth;
+        if (!eglGetConfigAttrib(GetDisplay(), config_, EGL_BUFFER_SIZE,
+                                &config_depth)) {
+          LOG(ERROR) << "eglGetConfigAttrib failed with error "
+                     << GetLastEGLErrorString();
+          return NULL;
+        }
+
+        if (config_depth == chosen_attribs[kBufferSizeOffset]) {
+          return config_;
+        }
+      }
+
+      // Try without an alpha channel.
+      config_attribs[kAlphaSizeOffset] = 0;
+      chosen_attribs =
+          ui::SurfaceFactoryOzone::GetInstance()->GetEGLSurfaceProperties(
+              config_attribs, ozone_surface_.get());
+      if (!eglChooseConfig(GetDisplay(), chosen_attribs, &config_, 1,
+                           &num_configs)) {
+        LOG(ERROR) << "eglChooseConfig failed with error "
+                   << GetLastEGLErrorString();
+        return NULL;
+      }
+
+      if (num_configs == 0) {
+        LOG(ERROR) << "No suitable EGL configs found.";
+        return NULL;
+      }
+    }
+    return config_;
+  }
 
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
   virtual ~GLSurfaceOzoneEGL() {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
 
   bool ReinitializeNativeSurface() {
     scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
@@ skipping 62 matching lines @@
                                     GLImage* image,
                                     const Rect& bounds_rect,
                                     const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
   virtual bool IsOffscreen() override { return false; }
   virtual VSyncProvider* GetVSyncProvider() override {
     return vsync_provider_.get();
   }
-  virtual bool SupportsPostSubBuffer() override { return true; }
+  virtual bool SupportsPostSubBuffer() override {
+    return ozone_surface_->SupportsPartialSwap();
+  }
   virtual bool PostSubBuffer(int x, int y, int width, int height) override {
     // The actual sub buffer handling is handled at higher layers.
     SwapBuffers();
     return true;
   }
 
  private:
   virtual ~GLSurfaceOzoneSurfaceless() {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
@@ skipping 95 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx