Update from chromium https://crrev.com/302282

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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
@@ skipping 59 matching lines @@
 #endif
 
 class OMLSyncControlVSyncProvider
     : public gfx::SyncControlVSyncProvider {
  public:
   explicit OMLSyncControlVSyncProvider(gfx::AcceleratedWidget window)
       : SyncControlVSyncProvider(),
         window_(window) {
   }
 
-  virtual ~OMLSyncControlVSyncProvider() { }
+  ~OMLSyncControlVSyncProvider() override {}
 
  protected:
-  virtual bool GetSyncValues(int64* system_time,
-                             int64* media_stream_counter,
-                             int64* swap_buffer_counter) override {
+  bool GetSyncValues(int64* system_time,
+                     int64* media_stream_counter,
+                     int64* swap_buffer_counter) override {
     return glXGetSyncValuesOML(g_display, window_, system_time,
                                media_stream_counter, swap_buffer_counter);
   }
 
-  virtual bool GetMscRate(int32* numerator, int32* denominator) override {
+  bool GetMscRate(int32* numerator, int32* denominator) override {
     if (!g_glx_get_msc_rate_oml_supported)
       return false;
 
     if (!glXGetMscRateOML(g_display, window_, numerator, denominator)) {
       // Once glXGetMscRateOML has been found to fail, don't try again,
       // since each failing call may spew an error message.
       g_glx_get_msc_rate_oml_supported = false;
       return false;
     }
 
@@ skipping 19 matching lines @@
     return g_video_sync_thread;
   }
 
  private:
   friend class base::RefCounted<SGIVideoSyncThread>;
 
   SGIVideoSyncThread() : base::Thread("SGI_video_sync") {
     DCHECK(CalledOnValidThread());
   }
 
-  virtual ~SGIVideoSyncThread() {
+  ~SGIVideoSyncThread() override {
     DCHECK(CalledOnValidThread());
     g_video_sync_thread = NULL;
     Stop();
   }
 
   static SGIVideoSyncThread* g_video_sync_thread;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncThread);
 };
 
@@ skipping 108 matching lines @@
       : vsync_thread_(SGIVideoSyncThread::Create()),
         shim_(new SGIVideoSyncProviderThreadShim(window)),
         cancel_vsync_flag_(shim_->cancel_vsync_flag()),
         vsync_lock_(shim_->vsync_lock()) {
     vsync_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&SGIVideoSyncProviderThreadShim::Initialize,
                    base::Unretained(shim_.get())));
   }
 
-  virtual ~SGIVideoSyncVSyncProvider() {
+  ~SGIVideoSyncVSyncProvider() override {
     {
       base::AutoLock locked(*vsync_lock_);
       cancel_vsync_flag_->Set();
     }
 
     // Hand-off |shim_| to be deleted on the |vsync_thread_|.
     vsync_thread_->message_loop()->DeleteSoon(
         FROM_HERE,
         shim_.release());
   }
 
-  virtual void GetVSyncParameters(
+  void GetVSyncParameters(
       const VSyncProvider::UpdateVSyncCallback& callback) override {
     if (kGetVSyncParametersMinPeriod > base::TimeDelta()) {
       base::TimeTicks now = base::TimeTicks::Now();
       base::TimeDelta delta = now - last_get_vsync_parameters_time_;
       if (delta < kGetVSyncParametersMinPeriod)
         return;
       last_get_vsync_parameters_time_ = now;
     }
 
     // Only one outstanding request per surface.
@@ skipping 407 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx