Update from https://crrev.com/304121

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.
 
 #include "ui/gl/gl_surface_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
@@ skipping 27 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 // From ANGLE's egl/eglext.h.
 #if !defined(EGL_PLATFORM_ANGLE_ANGLE)
 #define EGL_PLATFORM_ANGLE_ANGLE 0x3201
 #endif
 #if !defined(EGL_PLATFORM_ANGLE_TYPE_ANGLE)
 #define EGL_PLATFORM_ANGLE_TYPE_ANGLE 0x3202
 #endif
-#if !defined(EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE)
-#define EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE 0x3206
+#if !defined(EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+#define EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE 0x3207
+#endif
+#if !defined(EGL_PLATFORM_ANGLE_USE_WARP_ANGLE)
+#define EGL_PLATFORM_ANGLE_USE_WARP_ANGLE 0x3208
 #endif
 #endif  // defined(OS_WIN)
 
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
-unsigned int NativeViewGLSurfaceEGL::current_swap_generation_ = 0;
-
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 
 const char* g_egl_extensions = NULL;
 bool g_egl_create_context_robustness_supported = false;
 bool g_egl_sync_control_supported = false;
 bool g_egl_window_fixed_size_supported = false;
@@ skipping 176 matching lines @@
 }
 
 bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
 #if defined(OS_WIN)
 static const EGLint kDisplayAttribsWarp[] {
-  EGL_PLATFORM_ANGLE_TYPE_ANGLE,
-  EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE,
+  EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
+  EGL_PLATFORM_ANGLE_USE_WARP_ANGLE, EGL_TRUE,
   EGL_NONE
 };
 
 // static
 EGLDisplay GLSurfaceEGL::GetPlatformDisplay(
     EGLNativeDisplayType native_display) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseWarp)) {
     // Check for availability of WARP via ANGLE extension.
     bool supports_warp = false;
     const char* no_display_extensions = eglQueryString(EGL_NO_DISPLAY,
@@ skipping 14 matching lines @@
 
   return eglGetDisplay(native_display);
 }
 #endif
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL),
-      size_(1, 1),
-      swap_interval_(1),
-      swap_generation_(0) {
+      size_(1, 1) {
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 
 #if defined(OS_WIN)
   RECT windowRect;
   if (GetClientRect(window_, &windowRect))
     size_ = gfx::Rect(windowRect).size();
 #endif
@@ skipping 143 matching lines @@
 
 bool NativeViewGLSurfaceEGL::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceEGL::SwapBuffers() {
   TRACE_EVENT2("gpu", "NativeViewGLSurfaceEGL:RealSwapBuffers",
       "width", GetSize().width(),
       "height", GetSize().height());
 
-#if defined(OS_WIN)
-  bool force_no_vsync = false;
-  if (swap_interval_ != 0) {
-    // This code is a simple way of enforcing that only one surface actually
-    // vsyncs per frame. This provides single window cases a stable refresh
-    // while allowing multi-window cases to not slow down due to multiple syncs
-    // on a single thread. A better way to fix this problem would be to have
-    // each surface present on its own thread.
-    if (current_swap_generation_ == swap_generation_) {
-      current_swap_generation_++;
-    } else {
-      force_no_vsync = true;
-      eglSwapInterval(GetDisplay(), 0);
-    }
-
-    swap_generation_ = current_swap_generation_;
-  }
-#endif
-
   if (!eglSwapBuffers(GetDisplay(), surface_)) {
     DVLOG(1) << "eglSwapBuffers failed with error "
              << GetLastEGLErrorString();
     return false;
   }
 
-#if defined(OS_WIN)
-  if (force_no_vsync) {
-    eglSwapInterval(GetDisplay(), swap_interval_);
-  }
-#endif
-
   return true;
 }
 
 gfx::Size NativeViewGLSurfaceEGL::GetSize() {
   EGLint width;
   EGLint height;
   if (!eglQuerySurface(GetDisplay(), surface_, EGL_WIDTH, &width) ||
       !eglQuerySurface(GetDisplay(), surface_, EGL_HEIGHT, &height)) {
     NOTREACHED() << "eglQuerySurface failed with error "
                  << GetLastEGLErrorString();
@@ skipping 54 matching lines @@
              << GetLastEGLErrorString();
     return false;
   }
   return true;
 }
 
 VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
-void NativeViewGLSurfaceEGL::SetSwapInterval(int interval) {
-  swap_interval_ = interval;
-}
-
 NativeViewGLSurfaceEGL::~NativeViewGLSurfaceEGL() {
   Destroy();
 #if defined(OS_ANDROID)
   if (window_)
     ANativeWindow_release(window_);
 #endif
 }
 
 PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(const gfx::Size& size)
     : size_(size),
@@ skipping 162 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx