Add 16-bit support for browser compositor surface

ui/gl/gl_surface_egl.cc

 // Copyright (c) 2012 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.
 
 // This include must be here so that the includes provided transitively
 // by gl_surface_egl.h don't make it impossible to compile this code.
 #include "third_party/mesa/src/include/GL/osmesa.h"
 
 #include "ui/gl/gl_surface_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
+#include "base/android/sys_utils.h"
 #endif
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "build/build_config.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
@@ skipping 64 matching lines @@
   virtual bool GetMscRate(int32* numerator, int32* denominator) OVERRIDE {
     return false;
   }
 
  private:
   EGLSurface surface_;
 
   DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
 };
 
+bool ValidateEglConfig(EGLDisplay display,
+                       const EGLint* config_attribs,
+                       EGLint* num_configs) {
+  if (!eglChooseConfig(display,
+                       config_attribs,
+                       NULL,
+                       0,
+                       num_configs)) {
+    LOG(ERROR) << "eglChooseConfig failed with error "
+               << GetLastEGLErrorString();
+    return false;
+  }
+  if (*num_configs == 0) {
+    LOG(ERROR) << "No suitable EGL configs found.";
+    return false;
+  }
+  return true;
+}
+
 }  // namespace
 
 GLSurfaceEGL::GLSurfaceEGL() {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
 #if defined(USE_X11)
@@ skipping 23 matching lines @@
     return false;
   }
 
   if (!eglInitialize(g_display, NULL, NULL)) {
     LOG(ERROR) << "eglInitialize failed with error " << GetLastEGLErrorString();
     return false;
   }
 
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
-  static const EGLint kConfigAttribs[] = {
+  static EGLint config_attribs_8888[] = {
     EGL_BUFFER_SIZE, 32,
     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_PBUFFER_BIT,
     EGL_NONE
   };
 
+#if defined(OS_ANDROID)
+  static EGLint config_attribs_565[] = {
+    EGL_BUFFER_SIZE, 16,
+    EGL_BLUE_SIZE, 5,
+    EGL_GREEN_SIZE, 6,
+    EGL_RED_SIZE, 5,
+    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+    EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+    EGL_NONE
+  };
+#endif
+  EGLint* choose_attributes = config_attribs_8888;
+
+#if defined(OS_ANDROID)
+  if (base::android::SysUtils::IsLowEndDevice()) {
+    choose_attributes = config_attribs_565;
+  }
+#endif
+
 #if defined(USE_OZONE)
   const EGLint* config_attribs =
-      surface_factory->GetEGLSurfaceProperties(kConfigAttribs);
+      surface_factory->GetEGLSurfaceProperties(choose_attributes);
 #else
-  const EGLint* config_attribs = kConfigAttribs;
+  const EGLint* config_attribs = choose_attributes;
 #endif
 
   EGLint num_configs;
+  EGLint config_size = 1;
+  EGLConfig* config_data = &g_config;
+  // Validate if there are any configs for given atrribs.
+  if (!ValidateEglConfig(g_display,
+                         config_attribs,
+                         &num_configs)) {
+    return false;
+  }
+
+#if defined(OS_ANDROID)
+  scoped_ptr<EGLConfig[]> matching_configs(new EGLConfig[num_configs]);
+  if (base::android::SysUtils::IsLowEndDevice()) {
+    config_size = num_configs;
+    config_data = matching_configs.get();
+  }
+#endif
+
   if (!eglChooseConfig(g_display,
                        config_attribs,
-                       NULL,
-                       0,
+                       config_data,
+                       config_size,
                        &num_configs)) {
     LOG(ERROR) << "eglChooseConfig failed with error "
                << GetLastEGLErrorString();
     return false;
   }
 
-  if (num_configs == 0) {
-    LOG(ERROR) << "No suitable EGL configs found.";
-    return false;
+#if defined(OS_ANDROID)
+  if (base::android::SysUtils::IsLowEndDevice()) {
+    // Because of the EGL config sort order, we have to iterate
+    // through all of them (it'll put higher sum(R,G,B) bits
+    // first with the above attribs).
+    bool match_found = false;
+    for (int i = 0; i < num_configs; i++) {
+      EGLBoolean success;
+      EGLint red, green, blue;
+      // Read the relevent attributes of the EGLConfig.
+      success = eglGetConfigAttrib(g_display, matching_configs[i],
+                                   EGL_RED_SIZE, &red);
+      success &= eglGetConfigAttrib(g_display, matching_configs[i],
+                                    EGL_BLUE_SIZE, &blue);
+      success &= eglGetConfigAttrib(g_display, matching_configs[i],
+                                    EGL_GREEN_SIZE, &green);
+      if ((success == EGL_TRUE) && (red == 5) &&
+          (green == 6) && (blue == 5)) {
+        g_config = matching_configs[i];
+        match_found = true;
+        break;
+      }
+    }
+    if (!match_found) {
+      // To fall back to default 32 bit format, choose with
+      // the right attributes again.
+      if (!ValidateEglConfig(g_display,
+                             config_attribs_8888,
+                             &num_configs)) {
+        return false;
+      }
+      if (!eglChooseConfig(g_display,
+                           config_attribs_8888,
+                           &g_config,
+                           1,
+                           &num_configs)) {
+        LOG(ERROR) << "eglChooseConfig failed with error "
+                   << GetLastEGLErrorString();
+        return false;
+      }
+    }
   }
 
-  if (!eglChooseConfig(g_display,
-                       config_attribs,
-                       &g_config,
-                       1,
-                       &num_configs)) {
-    LOG(ERROR) << "eglChooseConfig failed with error "
-               << GetLastEGLErrorString();
-    return false;
-  }
+#endif
 
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   g_egl_create_context_robustness_supported =
       HasEGLExtension("EGL_EXT_create_context_robustness");
   g_egl_sync_control_supported =
       HasEGLExtension("EGL_CHROMIUM_sync_control");
 
   // Check if SurfacelessEGL is supported.
   g_egl_surfaceless_context_supported =
       HasEGLExtension("EGL_KHR_surfaceless_context");
@@ skipping 573 matching lines @@
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx