gl: Disable SGI_video_sync by default.

ui/gl/gl_surface_glx.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_glx.h"
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 #include <memory>
 
+#include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
@@ skipping 376 matching lines @@
   g_glx_create_context_profile_es2_supported =
       HasGLXExtension("GLX_ARB_create_context_es2_profile");
   g_glx_texture_from_pixmap_supported =
       HasGLXExtension("GLX_EXT_texture_from_pixmap");
   g_glx_oml_sync_control_supported =
       HasGLXExtension("GLX_OML_sync_control");
   g_glx_get_msc_rate_oml_supported = g_glx_oml_sync_control_supported;
   g_glx_sgi_video_sync_supported =
       HasGLXExtension("GLX_SGI_video_sync");
 
   if (!g_glx_get_msc_rate_oml_supported && g_glx_sgi_video_sync_supported)

[danakj, 2016/08/24 22:20:50]

Do you want to do this without the command line? Should we maybe just make
g_glx_sgi_video_sync_supported = false when the command line isnt present?

[brianderson, 2016/08/24 23:51:19]

Sounds like a good idea.

     SGIVideoSyncProviderThreadShim::display_ = gfx::OpenNewXDisplay();
 
   initialized = true;
   return true;
 }
 
 // static
 const char* GLSurfaceGLX::GetGLXExtensions() {
   return glXQueryExtensionsString(g_display, 0);
 }
@@ skipping 74 matching lines @@
   if (event_source) {
     XSelectInput(g_display, window_, ExposureMask);
     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   }
   XFlush(g_display);
 
   GetConfig();
   DCHECK(config_);
   glx_window_ = glXCreateWindow(g_display, config_, window_, NULL);
 
-  if (g_glx_oml_sync_control_supported)
+  if (g_glx_oml_sync_control_supported) {
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(glx_window_));
-  else if (g_glx_sgi_video_sync_supported)
+  } else if (g_glx_sgi_video_sync_supported &&
+             base::CommandLine::ForCurrentProcess()->HasSwitch(
+               switches::kEnableSgiVideoSync)) {
     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(config_, glx_window_));
+  } else {
+    // Assume a refresh rate of 59.9 Hz, which will cause us to skip
+    // 1 frame every 10 seconds on a 60Hz monitor, but will prevent us
+    // from blocking the GPU service due to back pressure. This would still
+    // encounter backpressure on a <60Hz monitor, but hopefully that is
+    // not common.

[piman, 2016/08/24 21:04:29]

The investigation for bug
https://bugs.chromium.org/p/chromium/issues/detail?id=262437 (where we would
reduce frame rate to 30Hz when the monitor was anywhere below 60) showed that
it's very common unfortunately. 50 or 55Hz is probably a safer lower bound (at
the cost of more missed frames).

We used to have a UMA histogram for the refresh rate
(GPU.AcceleratedSurfaceRefreshRate) but apparently it broke eons ago.

[danakj, 2016/08/24 22:20:50]

Why not just grab the actual refresh rate here? We have an x display. It looks
like this gives an int instead of something more accurate, but maybe good
enough?

int event, error;
int fps = 50;
if (XRRQueryExtension(&event, &error)) {
  XRRScreenConfiguration *conf = XRRGetScreenInfo(g_display, parent_window_);
  fps = XRRConfigCurrentRate(conf);
  XRRFreeScreenConfigInfo(conf);
}

+    const base::TimeTicks kDefaultTimebase;
+    const base::TimeDelta kDefaultInterval =
+        base::TimeDelta::FromSeconds(1) / 59.9;
+    vsync_provider_.reset(
+        new gfx::VSyncProviderStub(kDefaultTimebase, kDefaultInterval));
+  }
 
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
   vsync_provider_.reset();
   if (glx_window_) {
     glXDestroyWindow(g_display, glx_window_);
     glx_window_ = 0;
   }
@@ skipping 138 matching lines @@
   if (!config_)
     config_ = GetConfigForWindow(g_display, window_);
   return config_;
 }
 
 UnmappedNativeViewGLSurfaceGLX::~UnmappedNativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gl