When --disable-gpu-vsync, run requestAnimFrame callbacks at top speed.

content/renderer/render_widget.cc

 // Copyright (c) 2011 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 "content/renderer/render_widget.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 12 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenu.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenuInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRange.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/surface/transport_dib.h"
+#include "ui/gfx/gl/gl_switches.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #endif  // defined(OS_POSIX)
 
@@ skipping 535 matching lines @@
 
   SkIRect irect;
   irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
   canvas->drawIRect(irect, paint);
 }
 
 void RenderWidget::AnimationCallback() {
   animation_task_posted_ = false;
   if (!animation_update_pending_)
     return;
-  if (!animation_floor_time_.is_null()) {
+  if (!animation_floor_time_.is_null() && IsRenderingVSyncd()) {
     // Record when we fired (according to base::Time::Now()) relative to when
     // we posted the task to quantify how much the base::Time/base::TimeTicks
     // skew is affecting animations.
     base::TimeDelta animation_callback_delay = base::Time::Now() -
         (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
                                animation_callback_delay,
                                base::TimeDelta::FromMilliseconds(0),
                                base::TimeDelta::FromMilliseconds(30),
                                25);
   }
   DoDeferredUpdateAndSendInputAck();
 }
 
 void RenderWidget::AnimateIfNeeded() {
   if (!animation_update_pending_)
     return;
-  base::Time now = base::Time::Now();
-  if (now >= animation_floor_time_) {
-    animation_floor_time_ = now + base::TimeDelta::FromMilliseconds(16);
-    // Set a timer to call us back after 16ms (targetting 60FPS) before
-    // running animation callbacks so that if a callback requests another
-    // we'll be sure to run it at the proper time.
-    MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(
-        this, &RenderWidget::AnimationCallback), 16);
+  if(IsRenderingVSyncd()) {
+    base::Time now = base::Time::Now();
+    if (now >= animation_floor_time_) {
+      animation_floor_time_ = now + base::TimeDelta::FromMilliseconds(16);
+      // Set a timer to call us back after 16ms (targetting 60FPS) before
+      // running animation callbacks so that if a callback requests another
+      // we'll be sure to run it at the proper time.
+      MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(
+          this, &RenderWidget::AnimationCallback), 16);

[jamesr, 2011/05/26 02:20:15]

would it be sufficient to leave this function unchanged except to replace all
instances of '16' with 'IsRenderingVSyncd() ? 16 : 0' (although not as ugly as
with a ternary)?  I'm a bit brain tired but it's not immediately clear what
all's going on here and I'm kinda hoping that's an easy way out.

+      animation_task_posted_ = true;
+      animation_update_pending_ = false;
+  #ifdef WEBWIDGET_HAS_ANIMATE_CHANGES
+      webwidget_->animate(0.0);
+  #else
+      webwidget_->animate();
+  #endif
+      return;
+    }
+    TRACE_EVENT0("renderer", "EarlyOut_AnimatedInLast16ms");
+    if (animation_task_posted_)
+      return;
+    // This code uses base::Time::Now() to calculate the floor and next fire
+    // time because javascript's Date object uses base::Time::Now().  The
+    // message loop uses base::TimeTicks, which on windows can have a
+    // different granularity than base::Time.
+    // The upshot of all this is that this function might be called before
+    // base::Time::Now() has advanced past the animation_floor_time_.  To
+    // avoid exposing this delay to javascript, we keep posting delayed
+    // tasks until base::Time::Now() has advanced far enough.
+    int64 delay = (animation_floor_time_ - now).InMillisecondsRoundedUp();
     animation_task_posted_ = true;
+    MessageLoop::current()->PostDelayedTask(FROM_HERE,
+        NewRunnableMethod(this, &RenderWidget::AnimationCallback), delay);
+  } else {
     animation_update_pending_ = false;
 #ifdef WEBWIDGET_HAS_ANIMATE_CHANGES
     webwidget_->animate(0.0);
 #else
     webwidget_->animate();
 #endif
-    return;
+    // Set a delayed task to call us back "immediately" if more animation is
+    // requested, using delayed tasks to keep scheduling consistent. If we have
+    // hit the throttling threshold for swapbuffers, this task will be harmless.
+    // so that we get equivalent scheduling to the non-vsync'd case.
+    if(animation_update_pending_) {
+      MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(
+          this, &RenderWidget::AnimationCallback), 0);
+      animation_task_posted_ = true;
+    }
   }
-  if (animation_task_posted_)
-    return;
-  // This code uses base::Time::Now() to calculate the floor and next fire
-  // time because javascript's Date object uses base::Time::Now().  The
-  // message loop uses base::TimeTicks, which on windows can have a
-  // different granularity than base::Time.
-  // The upshot of all this is that this function might be called before
-  // base::Time::Now() has advanced past the animation_floor_time_.  To
-  // avoid exposing this delay to javascript, we keep posting delayed
-  // tasks until base::Time::Now() has advanced far enough.
-  int64 delay = (animation_floor_time_ - now).InMillisecondsRoundedUp();
-  animation_task_posted_ = true;
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      NewRunnableMethod(this, &RenderWidget::AnimationCallback), delay);
+}
+
+bool RenderWidget::IsRenderingVSyncd() {
+  // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
+  // not caught by this check. This will lead to artificially low frame rates
+  // for people who force vsync off at a driver level and expect Chrome to speed
+  // up.
+  return !CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kDisableGpuVsync);
 }
 
 void RenderWidget::InvalidationCallback() {
   invalidation_task_posted_ = false;
   DoDeferredUpdateAndSendInputAck();
 }
 
 void RenderWidget::DoDeferredUpdateAndSendInputAck() {
   DoDeferredUpdate();
 
@@ skipping 659 matching lines @@
 
 void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
   for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
        i != plugin_window_moves_.end(); ++i) {
     if (i->window == window) {
       plugin_window_moves_.erase(i);
       break;
     }
   }
 }