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/bind.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/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
@@ skipping 30 matching lines @@
   }
   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);
   }
 
+  EGLConfig GetConfig() override {
+    if (!config_) {
+      ui::SurfaceFactoryOzone::EglConfigInfo egl;
+      egl.choose_config = base::Bind(&GLSurfaceOzoneEGL::EglChooseConfig,
+                                     base::Unretained(this));
+      egl.get_config_attribute = base::Bind(
+          &GLSurfaceOzoneEGL::EglGetConfigAttribute, base::Unretained(this));
+      egl.get_last_error_string = base::Bind(&ui::GetLastEGLErrorString);
+      config_ = ui::SurfaceFactoryOzone::GetInstance()->GetEGLSurfaceConfig(
+          egl, ozone_surface_.get());
+    }
+    if (config_)
+      return config_;
+    return NativeViewGLSurfaceEGL::GetConfig();
+  }
+
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
   virtual ~GLSurfaceOzoneEGL() {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
 
+  bool EglChooseConfig(const int32* attribs,
+                       void** /* EGLConfig* */ configs,
+                       int32 config_size,
+                       int32* num_configs) {
+    return eglChooseConfig(GetDisplay(), attribs, configs, config_size,
+                           num_configs);
+  }
+
+  bool EglGetConfigAttribute(void* /* EGLConfig */ config,
+                             int32 attribute,
+                             int32* value) {
+    return eglGetConfigAttrib(GetDisplay(), config, attribute, value);
+  }
+
   bool ReinitializeNativeSurface() {
     scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
     GLContext* current_context = GLContext::GetCurrent();
     bool was_current =
         current_context && current_context->IsCurrent(this);
     if (was_current) {
       scoped_make_current.reset(
           new ui::ScopedMakeCurrent(current_context, this));
     }
 
@@ skipping 170 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx