diff options
Diffstat (limited to 'eglGetMscRateCHROMIUM.patch')
| -rw-r--r-- | eglGetMscRateCHROMIUM.patch | 604 |
1 files changed, 604 insertions, 0 deletions
diff --git a/eglGetMscRateCHROMIUM.patch b/eglGetMscRateCHROMIUM.patch new file mode 100644 index 0000000..0755763 --- /dev/null +++ b/eglGetMscRateCHROMIUM.patch @@ -0,0 +1,604 @@ +From 5cddfb828ddd82fc741549d5ee44cd9b94bd97f5 Mon Sep 17 00:00:00 2001 +From: Jonah Ryan-Davis <jonahr@google.com> +Date: Mon, 30 Mar 2020 17:13:54 +0000 +Subject: [PATCH] Use EGL_ANGLE_sync_control_rate for eglGetMscRate call + +eglGetMscRateCHROMIUM is not universally supported, so we will +switch to using the ANGLE version of the extension instead. + +Bug: chromium:1064078 +Change-Id: Ic57e2e55230df1d1c2c584e1cbf54331330a0b87 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2120453 +Reviewed-by: Zhenyao Mo <zmo@chromium.org> +Commit-Queue: Jonah Ryan-Davis <jonahr@google.com> +Cr-Commit-Position: refs/heads/master@{#754518} +--- + +diff --git a/gpu/GLES2/extensions/ANGLE/EGL_ANGLE_sync_control_rate.txt b/gpu/GLES2/extensions/ANGLE/EGL_ANGLE_sync_control_rate.txt +new file mode 100644 +index 0000000..2056ae8 +--- /dev/null ++++ b/gpu/GLES2/extensions/ANGLE/EGL_ANGLE_sync_control_rate.txt +@@ -0,0 +1,110 @@ ++Name ++ ++ ANGLE_sync_control_rate ++ ++Name Strings ++ ++ EGL_ANGLE_sync_control_rate ++ ++Contact ++ ++ Jonah Ryan-Davis, Google (jonahr 'at' google.com) ++ ++Status ++ ++ Draft. ++ ++Version ++ ++ Version 1, 2020-03-24 ++ ++ Based on GLX_OML_sync_control Revision 6.0 ++ ++Number ++ ++ ??? ++ ++Dependencies ++ ++ The extension is written against the EGL 1.2 Specification, although it ++ should work on other versions of these specifications. This extension ++ also requires an operating system which supports CLOCK_MONOTONIC. ++ ++Overview ++ ++ This extension provides counters which let applications know about the ++ timing of the last vertical retrace. By looking at the system clock, as ++ well as the refresh rate of the monitor, this should enable applications ++ to predict the position of future retraces so as to schedule an optimal ++ workload. ++ ++ This extension incorporates the use of three counters that provide ++ the necessary synchronization. The Unadjusted System Time (or UST) ++ is the 64-bit CLOCK_MONOTONIC clock; in particular this lets the ++ application schedule future vertical retraces by querying this clock. ++ The graphics Media Stream Counter (or graphics MSC) is a counter ++ that is unique to the graphics subsystem and increments for each ++ vertical retrace that occurs. The Swap Buffer Counter (SBC) is an ++ attribute of an EGLSurface and is incremented each time a swap ++ buffer action is performed on the associated surface. ++ ++ The use of these three counters allows the application to ++ synchronize graphics rendering to vertical retraces and/or swap ++ buffer actions. For example, by querying the synchronization values for ++ a given surface, the application can accurately predict the timing for ++ the next vertical retraces and schedule rendering accordingly. ++ ++Issues ++ ++ None. ++ ++IP Status ++ ++ No known issues. ++ ++New Procedures and Functions ++ ++ Bool eglGetMscRateANGLE(EGLDisplay* dpy, ++ EGLSurface surface, ++ int32_t* numerator, ++ int32_t* denominator) ++ ++New Tokens ++ ++ None ++ ++Additions to the EGL 1.3 Specification ++ ++ The graphics MSC value is incremented once for each screen refresh. ++ For a non-interlaced display, this means that the graphics MSC value ++ is incremented for each frame. For an interlaced display, it means ++ that it will be incremented for each field. For a multi-monitor ++ system, the monitor used to determine MSC is the one where the surface ++ is located. If the surface spans multiple monitors, the monitor used ++ to determine MSC is the one with the biggest coverage in pixels. ++ ++ eglGetMscRateANGLE returns the rate at which the MSC will be incremented ++ for the display associated with <hdc>. The rate is expressed in Hertz ++ as <numerator> / <denominator>. If the MSC rate in Hertz is an ++ integer, then <denominator> will be 1 and <numerator> will be ++ the MSC rate. ++ ++ The function eglGetMscRateANGLE will return TRUE if the function ++ completed successfully, FALSE otherwise. ++ ++ Each time eglSwapBuffer succeeds, the SBC will be increased within a ++ finite time period. ++ ++Errors ++ ++ The function eglGetMscRateANGLE will return FALSE if there is no ++ current EGLContext. ++ ++New Implementation Dependent State ++ ++ None ++ ++Revision History ++ ++ Version 1, 2020-03-24 (Jonah Ryan-Davis) ++ - Initial draft, based on GLX_OML_sync_control revision 6.0. +diff --git a/gpu/GLES2/extensions/CHROMIUM/EGL_CHROMIUM_sync_control.txt b/gpu/GLES2/extensions/CHROMIUM/EGL_CHROMIUM_sync_control.txt +index 14f4e56..f699f61 100644 +--- a/gpu/GLES2/extensions/CHROMIUM/EGL_CHROMIUM_sync_control.txt ++++ b/gpu/GLES2/extensions/CHROMIUM/EGL_CHROMIUM_sync_control.txt +@@ -16,7 +16,7 @@ + + Version + +- Version 3, 2020-01-23 ++ Version 2, 2015-05-05 + + Based on GLX_OML_sync_control Revision 6.0 + +@@ -70,12 +70,6 @@ + int64_t* msc, + int64_t* sbc) + +- Bool eglGetMscRateCHROMIUM(EGLDisplay* dpy, +- EGLSurface surface, +- int32_t* numerator, +- int32_t* denominator) +- +- + New Tokens + + None +@@ -112,22 +106,16 @@ + is located. If the surface spans multiple monitors, the monitor used + to determine MSC is the one with the biggest coverage in pixels. + +- eglGetMscRateCHROMIUM returns the rate at which the MSC will be incremented +- for the display associated with <hdc>. The rate is expressed in Hertz +- as <numerator> / <denominator>. If the MSC rate in Hertz is an +- integer, then <denominator> will be 1 and <numerator> will be +- the MSC rate. +- +- The functions eglGetSyncValuesCHROMIUM, and eglGetMscRateCHROMIUM will +- return TRUE if the function completed successfully, FALSE otherwise. ++ The function eglGetSyncValuesCHROMIUM will return TRUE if the function ++ completed successfully, FALSE otherwise. + + Each time eglSwapBuffer succeeds, the SBC will be increased within a + finite time period. + + Errors + +- The functions eglGetSyncValuesCHROMIUM, and eglGetMscRateCHROMIUM will +- return FALSE if there is no current EGLContext. ++ The function eglGetSyncValuesCHROMIUM will return FALSE if there is no ++ current EGLContext. + + + New State +@@ -144,10 +132,6 @@ + + Revision History + +- Version 3, 2020-01-23 (Jonah Ryan-Davis) +- - Add the function eglGetMscRateCHROMIUM based on glXGetMscRateOML from +- GLX_OML_sync_control revision 6.0. +- + Version 2, 2015-05-05 (Chad Versace) + - Rename to EGL_CHROMIUM_sync_control from EGL_CHROMIUM_get_sync_values. + EGL_CHROMIUM_sync_control is the de facto extension name because all +diff --git a/ui/gl/EGL/eglextchromium.h b/ui/gl/EGL/eglextchromium.h +index e66d34a..22e3cf0 100644 +--- a/ui/gl/EGL/eglextchromium.h ++++ b/ui/gl/EGL/eglextchromium.h +@@ -22,21 +22,26 @@ + EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncValuesCHROMIUM( + EGLDisplay dpy, EGLSurface surface, EGLuint64CHROMIUM *ust, + EGLuint64CHROMIUM *msc, EGLuint64CHROMIUM *sbc); +-EGLAPI EGLBoolean EGLAPIENTRY eglGetMscRateCHROMIUM(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator); + #endif /* EGL_EGLEXT_PROTOTYPES */ + typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCVALUESCHROMIUMPROC) + (EGLDisplay dpy, EGLSurface surface, EGLuint64CHROMIUM *ust, + EGLuint64CHROMIUM *msc, EGLuint64CHROMIUM *sbc); +-typedef EGLBoolean(EGLAPIENTRYP PFNEGLGETMSCRATECHROMIUMPROC)( +- EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator); +-#endif +-#endif ++#endif /* EGL_CHROMIUM_sync_control */ ++ ++#ifndef EGL_ANGLE_sync_control_rate ++#define EGL_ANGLE_sync_control_rate 1 ++#ifdef EGL_EGLEXT_PROTOTYPES ++EGLAPI EGLBoolean EGLAPIENTRY eglGetMscRateANGLE(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator); ++#endif /* EGL_EGLEXT_PROTOTYPES */ ++typedef EGLBoolean(EGLAPIENTRYP PFNEGLGETMSCRATEANGLEPROC)(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator); ++#endif /* EGL_ANGLE_sync_control_rate */ ++#endif /* KHRONOS_SUPPORT_INT64 */ + + #ifdef __cplusplus + } +diff --git a/ui/gl/egl_bindings_autogen_mock.cc b/ui/gl/egl_bindings_autogen_mock.cc +index f6562ad..d4d3a04 100644 +--- a/ui/gl/egl_bindings_autogen_mock.cc ++++ b/ui/gl/egl_bindings_autogen_mock.cc +@@ -299,12 +299,12 @@ + } + + EGLBoolean GL_BINDING_CALL +-MockEGLInterface::Mock_eglGetMscRateCHROMIUM(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator) { +- MakeEglMockFunctionUnique("eglGetMscRateCHROMIUM"); +- return interface_->GetMscRateCHROMIUM(dpy, surface, numerator, denominator); ++MockEGLInterface::Mock_eglGetMscRateANGLE(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator) { ++ MakeEglMockFunctionUnique("eglGetMscRateANGLE"); ++ return interface_->GetMscRateANGLE(dpy, surface, numerator, denominator); + } + + EGLClientBuffer GL_BINDING_CALL +@@ -706,8 +706,8 @@ + if (strcmp(name, "eglGetFrameTimestampsANDROID") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_eglGetFrameTimestampsANDROID); +- if (strcmp(name, "eglGetMscRateCHROMIUM") == 0) +- return reinterpret_cast<GLFunctionPointerType>(Mock_eglGetMscRateCHROMIUM); ++ if (strcmp(name, "eglGetMscRateANGLE") == 0) ++ return reinterpret_cast<GLFunctionPointerType>(Mock_eglGetMscRateANGLE); + if (strcmp(name, "eglGetNativeClientBufferANDROID") == 0) + return reinterpret_cast<GLFunctionPointerType>( + Mock_eglGetNativeClientBufferANDROID); +diff --git a/ui/gl/egl_bindings_autogen_mock.h b/ui/gl/egl_bindings_autogen_mock.h +index 06f1117..4b7eb01 100644 +--- a/ui/gl/egl_bindings_autogen_mock.h ++++ b/ui/gl/egl_bindings_autogen_mock.h +@@ -131,11 +131,10 @@ + EGLint numTimestamps, + EGLint* timestamps, + EGLnsecsANDROID* values); +-static EGLBoolean GL_BINDING_CALL +-Mock_eglGetMscRateCHROMIUM(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator); ++static EGLBoolean GL_BINDING_CALL Mock_eglGetMscRateANGLE(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator); + static EGLClientBuffer GL_BINDING_CALL Mock_eglGetNativeClientBufferANDROID( + const struct AHardwareBuffer* ahardwarebuffer); + static EGLBoolean GL_BINDING_CALL +diff --git a/ui/gl/generate_bindings.py b/ui/gl/generate_bindings.py +index 6a89047..01da79a 100755 +--- a/ui/gl/generate_bindings.py ++++ b/ui/gl/generate_bindings.py +@@ -2452,9 +2452,9 @@ + ] }], + 'arguments': 'EGLDisplay dpy, EGLSurface surface, EGLint timestamp', }, + { 'return_type': 'EGLBoolean', +- 'versions': [{ 'name': 'eglGetMscRateCHROMIUM', ++ 'versions': [{ 'name': 'eglGetMscRateANGLE', + 'extensions': [ +- 'EGL_CHROMIUM_sync_control' ++ 'EGL_ANGLE_sync_control_rate' + ] }], + 'arguments': + 'EGLDisplay dpy, EGLSurface surface, ' +diff --git a/ui/gl/gl_bindings_api_autogen_egl.h b/ui/gl/gl_bindings_api_autogen_egl.h +index 8628d7c..30b0ba80 100644 +--- a/ui/gl/gl_bindings_api_autogen_egl.h ++++ b/ui/gl/gl_bindings_api_autogen_egl.h +@@ -111,10 +111,10 @@ + EGLBoolean eglGetFrameTimestampSupportedANDROIDFn(EGLDisplay dpy, + EGLSurface surface, + EGLint timestamp) override; +-EGLBoolean eglGetMscRateCHROMIUMFn(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator) override; ++EGLBoolean eglGetMscRateANGLEFn(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator) override; + EGLClientBuffer eglGetNativeClientBufferANDROIDFn( + const struct AHardwareBuffer* ahardwarebuffer) override; + EGLBoolean eglGetNextFrameIdANDROIDFn(EGLDisplay dpy, +diff --git a/ui/gl/gl_bindings_autogen_egl.cc b/ui/gl/gl_bindings_autogen_egl.cc +index 2f1ed11..18444223 100644 +--- a/ui/gl/gl_bindings_autogen_egl.cc ++++ b/ui/gl/gl_bindings_autogen_egl.cc +@@ -187,6 +187,8 @@ + gfx::HasExtension(extensions, "EGL_ANGLE_stream_producer_d3d_texture"); + ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle = gfx::HasExtension( + extensions, "EGL_ANGLE_surface_d3d_texture_2d_share_handle"); ++ ext.b_EGL_ANGLE_sync_control_rate = ++ gfx::HasExtension(extensions, "EGL_ANGLE_sync_control_rate"); + ext.b_EGL_CHROMIUM_sync_control = + gfx::HasExtension(extensions, "EGL_CHROMIUM_sync_control"); + ext.b_EGL_EXT_image_flush_external = +@@ -278,9 +280,9 @@ + GetGLProcAddress("eglGetFrameTimestampSupportedANDROID")); + } + +- if (ext.b_EGL_CHROMIUM_sync_control) { +- fn.eglGetMscRateCHROMIUMFn = reinterpret_cast<eglGetMscRateCHROMIUMProc>( +- GetGLProcAddress("eglGetMscRateCHROMIUM")); ++ if (ext.b_EGL_ANGLE_sync_control_rate) { ++ fn.eglGetMscRateANGLEFn = reinterpret_cast<eglGetMscRateANGLEProc>( ++ GetGLProcAddress("eglGetMscRateANGLE")); + } + + if (ext.b_EGL_ANDROID_get_native_client_buffer) { +@@ -602,12 +604,11 @@ + timestamp); + } + +-EGLBoolean EGLApiBase::eglGetMscRateCHROMIUMFn(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator) { +- return driver_->fn.eglGetMscRateCHROMIUMFn(dpy, surface, numerator, +- denominator); ++EGLBoolean EGLApiBase::eglGetMscRateANGLEFn(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator) { ++ return driver_->fn.eglGetMscRateANGLEFn(dpy, surface, numerator, denominator); + } + + EGLClientBuffer EGLApiBase::eglGetNativeClientBufferANDROIDFn( +@@ -1117,13 +1118,12 @@ + timestamp); + } + +-EGLBoolean TraceEGLApi::eglGetMscRateCHROMIUMFn(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator) { +- TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetMscRateCHROMIUM") +- return egl_api_->eglGetMscRateCHROMIUMFn(dpy, surface, numerator, +- denominator); ++EGLBoolean TraceEGLApi::eglGetMscRateANGLEFn(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator) { ++ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetMscRateANGLE") ++ return egl_api_->eglGetMscRateANGLEFn(dpy, surface, numerator, denominator); + } + + EGLClientBuffer TraceEGLApi::eglGetNativeClientBufferANDROIDFn( +@@ -1811,16 +1811,16 @@ + return result; + } + +-EGLBoolean LogEGLApi::eglGetMscRateCHROMIUMFn(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator) { +- GL_SERVICE_LOG("eglGetMscRateCHROMIUM" ++EGLBoolean LogEGLApi::eglGetMscRateANGLEFn(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator) { ++ GL_SERVICE_LOG("eglGetMscRateANGLE" + << "(" << dpy << ", " << surface << ", " + << static_cast<const void*>(numerator) << ", " + << static_cast<const void*>(denominator) << ")"); + EGLBoolean result = +- egl_api_->eglGetMscRateCHROMIUMFn(dpy, surface, numerator, denominator); ++ egl_api_->eglGetMscRateANGLEFn(dpy, surface, numerator, denominator); + GL_SERVICE_LOG("GL_RESULT: " << result); + return result; + } +diff --git a/ui/gl/gl_bindings_autogen_egl.h b/ui/gl/gl_bindings_autogen_egl.h +index 546e2c9..6cafd14 100644 +--- a/ui/gl/gl_bindings_autogen_egl.h ++++ b/ui/gl/gl_bindings_autogen_egl.h +@@ -141,7 +141,7 @@ + EGLDisplay dpy, + EGLSurface surface, + EGLint timestamp); +-typedef EGLBoolean(GL_BINDING_CALL* eglGetMscRateCHROMIUMProc)( ++typedef EGLBoolean(GL_BINDING_CALL* eglGetMscRateANGLEProc)( + EGLDisplay dpy, + EGLSurface surface, + EGLint* numerator, +@@ -296,6 +296,7 @@ + bool b_EGL_ANGLE_query_surface_pointer; + bool b_EGL_ANGLE_stream_producer_d3d_texture; + bool b_EGL_ANGLE_surface_d3d_texture_2d_share_handle; ++ bool b_EGL_ANGLE_sync_control_rate; + bool b_EGL_CHROMIUM_sync_control; + bool b_EGL_EXT_image_flush_external; + bool b_EGL_KHR_fence_sync; +@@ -351,7 +352,7 @@ + eglGetFrameTimestampsANDROIDProc eglGetFrameTimestampsANDROIDFn; + eglGetFrameTimestampSupportedANDROIDProc + eglGetFrameTimestampSupportedANDROIDFn; +- eglGetMscRateCHROMIUMProc eglGetMscRateCHROMIUMFn; ++ eglGetMscRateANGLEProc eglGetMscRateANGLEFn; + eglGetNativeClientBufferANDROIDProc eglGetNativeClientBufferANDROIDFn; + eglGetNextFrameIdANDROIDProc eglGetNextFrameIdANDROIDFn; + eglGetPlatformDisplayProc eglGetPlatformDisplayFn; +@@ -512,10 +513,10 @@ + EGLDisplay dpy, + EGLSurface surface, + EGLint timestamp) = 0; +- virtual EGLBoolean eglGetMscRateCHROMIUMFn(EGLDisplay dpy, +- EGLSurface surface, +- EGLint* numerator, +- EGLint* denominator) = 0; ++ virtual EGLBoolean eglGetMscRateANGLEFn(EGLDisplay dpy, ++ EGLSurface surface, ++ EGLint* numerator, ++ EGLint* denominator) = 0; + virtual EGLClientBuffer eglGetNativeClientBufferANDROIDFn( + const struct AHardwareBuffer* ahardwarebuffer) = 0; + virtual EGLBoolean eglGetNextFrameIdANDROIDFn(EGLDisplay dpy, +@@ -685,8 +686,7 @@ + ::gl::g_current_egl_context->eglGetFrameTimestampsANDROIDFn + #define eglGetFrameTimestampSupportedANDROID \ + ::gl::g_current_egl_context->eglGetFrameTimestampSupportedANDROIDFn +-#define eglGetMscRateCHROMIUM \ +- ::gl::g_current_egl_context->eglGetMscRateCHROMIUMFn ++#define eglGetMscRateANGLE ::gl::g_current_egl_context->eglGetMscRateANGLEFn + #define eglGetNativeClientBufferANDROID \ + ::gl::g_current_egl_context->eglGetNativeClientBufferANDROIDFn + #define eglGetNextFrameIdANDROID \ +diff --git a/ui/gl/gl_enums_implementation_autogen.h b/ui/gl/gl_enums_implementation_autogen.h +index d35439c..1209923b 100644 +--- a/ui/gl/gl_enums_implementation_autogen.h ++++ b/ui/gl/gl_enums_implementation_autogen.h +@@ -829,10 +829,6 @@ + "GL_FILL_NV", + }, + { +- 0x1D00, +- "GL_FLAT_CHROMIUM", +- }, +- { + 0x1E00, + "GL_KEEP", + }, +@@ -877,14 +873,6 @@ + "GL_FONT_NUM_GLYPH_INDICES_BIT_NV", + }, + { +- 0x2400, +- "GL_EYE_LINEAR_CHROMIUM", +- }, +- { +- 0x2401, +- "GL_OBJECT_LINEAR_CHROMIUM", +- }, +- { + 0x2600, + "GL_NEAREST", + }, +@@ -2053,10 +2041,6 @@ + "GL_MAX_CUBE_MAP_TEXTURE_SIZE", + }, + { +- 0x8576, +- "GL_CONSTANT_CHROMIUM", +- }, +- { + 0x8589, + "GL_SRC1_ALPHA_EXT", + }, +@@ -4629,10 +4613,6 @@ + "GL_PATH_CLIENT_LENGTH_NV", + }, + { +- 0x907a, +- "GL_PATH_MITER_LIMIT_CHROMIUM", +- }, +- { + 0x9080, + "GL_PATH_FILL_MODE_NV", + }, +@@ -4653,10 +4633,6 @@ + "GL_PATH_STROKE_MASK_NV", + }, + { +- 0x9086, +- "GL_PATH_STROKE_BOUND_CHROMIUM", +- }, +- { + 0x9088, + "GL_COUNT_UP_NV", + }, +@@ -4965,14 +4941,6 @@ + "GL_CONTEXT_ROBUST_ACCESS_KHR", + }, + { +- 0x90a3, +- "GL_SQUARE_CHROMIUM", +- }, +- { +- 0x90a4, +- "GL_ROUND_CHROMIUM", +- }, +- { + 0x9100, + "GL_TEXTURE_2D_MULTISAMPLE", + }, +diff --git a/ui/gl/gl_mock_autogen_egl.h b/ui/gl/gl_mock_autogen_egl.h +index bcdd2a3..ba2f95f 100644 +--- a/ui/gl/gl_mock_autogen_egl.h ++++ b/ui/gl/gl_mock_autogen_egl.h +@@ -121,7 +121,7 @@ + EGLnsecsANDROID* values)); + MOCK_METHOD3(GetFrameTimestampSupportedANDROID, + EGLBoolean(EGLDisplay dpy, EGLSurface surface, EGLint timestamp)); +-MOCK_METHOD4(GetMscRateCHROMIUM, ++MOCK_METHOD4(GetMscRateANGLE, + EGLBoolean(EGLDisplay dpy, + EGLSurface surface, + EGLint* numerator, +diff --git a/ui/gl/gl_surface_egl.cc b/ui/gl/gl_surface_egl.cc +index 72268904..750f3ed 100644 +--- a/ui/gl/gl_surface_egl.cc ++++ b/ui/gl/gl_surface_egl.cc +@@ -174,6 +174,7 @@ + bool g_egl_create_context_bind_generates_resource_supported = false; + bool g_egl_create_context_webgl_compatability_supported = false; + bool g_egl_sync_control_supported = false; ++bool g_egl_sync_control_rate_supported = false; + bool g_egl_window_fixed_size_supported = false; + bool g_egl_surfaceless_context_supported = false; + bool g_egl_surface_orientation_supported = false; +@@ -266,8 +267,12 @@ + } + + bool GetMscRate(int32_t* numerator, int32_t* denominator) override { ++ if (!g_egl_sync_control_rate_supported) { ++ return false; ++ } ++ +- bool result = eglGetMscRateCHROMIUM(g_egl_display, surface_, numerator, +- denominator) == EGL_TRUE; ++ bool result = eglGetMscRateANGLE(g_egl_display, surface_, numerator, ++ denominator) == EGL_TRUE; + return result; + } + +@@ -921,6 +920,8 @@ + g_egl_create_context_webgl_compatability_supported = + HasEGLExtension("EGL_ANGLE_create_context_webgl_compatibility"); + g_egl_sync_control_supported = HasEGLExtension("EGL_CHROMIUM_sync_control"); ++ g_egl_sync_control_rate_supported = ++ HasEGLExtension("EGL_ANGLE_sync_control_rate"); + g_egl_window_fixed_size_supported = + HasEGLExtension("EGL_ANGLE_window_fixed_size"); + g_egl_surface_orientation_supported = +@@ -1036,6 +1037,7 @@ + g_egl_create_context_bind_generates_resource_supported = false; + g_egl_create_context_webgl_compatability_supported = false; + g_egl_sync_control_supported = false; ++ g_egl_sync_control_rate_supported = false; + g_egl_window_fixed_size_supported = false; + g_egl_surface_orientation_supported = false; + g_egl_surfaceless_context_supported = false; |