Adding support for animated pages in the FrameRate tests

chrome/test/data/perf/frame_rate/head.js

 // 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.
 
 /**
  * @fileoverview  Perform various "gestures" and calculate average frame rate.
  * "Gestures" are recorded scrolling behaviors in terms of time (ms) and
  * absolute positions.
  *
  * How to run a single gesture:
@@ skipping 20 matching lines @@
  *      new_gesture_name: [
  *        {"time_ms":1, "y":0},
  *        ... pasted output ...
  *      ],
  */
 
 var __running = false;
 var __running_all = false;
 var __old_title = "";
 var __raf_is_live = false;
+var __platform_raf;
 var __raf;
 
 var __t_last;
 var __t_est;
 var __t_est_total;
 var __t_est_squared_total;
 var __t_count;
 var __t_start;
 
 var __queued_gesture_functions;
 var __results;
 
 var __recording = [];
 var __advance_gesture;
-var __gestures = {
-  none: [
+var __animation = function() {return false;}
+
+var __gesture_library = {
+  init: [
+    {"time_ms":1, "y":0},
+    {"time_ms":5, "y":10}
+  ],
+  stationary: [
     {"time_ms":1, "y":0},
     {"time_ms":5000, "y":0}
   ],
-  steady: [
-    {"time_ms":1, "y":0},
-    {"time_ms":5, "y":10}
-  ],
   reading: [
     {"time_ms":1, "y":0},
     {"time_ms":842, "y":40},
     {"time_ms":858, "y":67},
     {"time_ms":874, "y":94},
     {"time_ms":890, "y":149},
     {"time_ms":907, "y":203},
     {"time_ms":923, "y":257},
     {"time_ms":939, "y":311},
     {"time_ms":955, "y":393},
@@ skipping 80 matching lines @@
     {"time_ms":911, "y":1273},
     {"time_ms":941, "y":1275},
     {"time_ms":958, "y":1282},
     {"time_ms":976, "y":1288},
     {"time_ms":993, "y":1291},
     {"time_ms":1022, "y":1294},
     {"time_ms":1055, "y":1302}
   ],
 };
 
+// Creat an alternate version of a gesture that
+// runs without using requestAnimationFrame
+function __gesture_disable_raf(gesture) {
+  // clone the gesture
+  var new_gesture = JSON.parse(JSON.stringify(gesture));
+  new_gesture[0].raf = false;
+  return new_gesture;
+}
+
+// Stretch the duration of a gesture by a given factor
+function __gesture_stretch(gesture, stretch_factor) {
+  // clone the gesture
+  var new_gesture = JSON.parse(JSON.stringify(gesture));
+  for (var i = 0; i < new_gesture.length; ++i) {
+    new_gesture[i].time_ms *= stretch_factor;
+  }
+  return new_gesture;
+}
+
+
+// Gesture set to use for testing, initialized with default gesture set.
+// Redefine in test file to use a different set of gestures.
+var __gestures = {
+  none: __gesture_library["stationary"],
+  steady: __gesture_library["init"],
+  reading: __gesture_library["reading"],
+  mouse_wheel: __gesture_library["mouse_wheel"],
+  mac_fling: __gesture_library["mac_fling"],
+};
+
 function __init_stats() {
   __t_last = undefined;
   __t_est = undefined;
   __t_est_total = 0;
   __t_est_squared_total = 0;
   __t_count = 0;
 }
 __init_stats();
 
+function __init_raf(use_raf) {
+  if (use_raf) {
+    if (!__platform_raf) {
+      if ("requestAnimationFrame" in window)

[nduca, 2011/10/10 23:11:19]

Nice!

+        __platform_raf = requestAnimationFrame;
+      else if ("webkitRequestAnimationFrame" in window)
+        __platform_raf = webkitRequestAnimationFrame;
+      else if ("mozRequestAnimationFrame" in window)
+        __platform_raf = mozRequestAnimationFrame;
+      else if ("oRequestAnimationFrame" in window)
+        __platform_raf = oRequestAnimationFrame;
+      else if ("msRequestAnimationFrame" in window)
+        __platform_raf = msRequestAnimationFrame;
+      else
+        // No raf implementation available, fake it with 16ms timeouts
+        __platform_raf = function(callback, element) {
+          setTimeout(callback, 16);
+        }
+    }
+    __raf = __platform_raf;
+  }
+  else {
+    // raf disabled: Using a 0ms timeout to render as fast as possible
+    __raf = function(callback, element) {
+      setTimeout(callback,0);
+    }
+  }
+}
+__init_raf(true);

[nduca, 2011/10/10 23:11:19]

Init raf here? Really?

+
 function __calc_results() {
   var M = __t_est_total / __t_count;
   var X = __t_est_squared_total / __t_count;
   var V = X - M * M;
   var S = Math.sqrt(V);
 
   var R = new Object();
   R.mean = 1000.0 / M;
   R.sigma = R.mean - 1000.0 / (M + S);
   return R;
@@ skipping 79 matching lines @@
   if (delta == 0)
     return false;
   window.scrollBy(0, delta);
   window.__scrolledTo = yfloor;
   return true;
 }
 
 // Returns true if a gesture movement occured.
 function __create_gesture_function(gestures) {
   var i0 = 0;
+  var use_raf = true;

[nduca, 2011/10/10 23:11:19]

Did you consider doing this feature outside of the test harness. E.g. launch
chrome with --disable-vsync? By pulling this in, I'm not quite sure what you're
buying... but its probably because you have something in mind that I dont. :)

   return function() {
     if (i0 >= gestures.length) {
       __stop();
       return false;
     }
     var time_cur = new Date().getTime() - __t_start;
     if (time_cur <= gestures[i0].time_ms)
       return false;
 
-    // Skip any keyframes that we missed
-    for (i0; i0 < gestures.length && gestures[i0].time_ms < time_cur; ++i0);
+    // Skip any keyframes that we missed and track changes to raf state
+    var new_use_raf = use_raf;
+    for (i0; i0 < gestures.length && gestures[i0].time_ms < time_cur; ++i0) {
+      if ("raf" in gestures[i0]) {
+        new_use_raf = gestures[i0].raf;
+      }
+    }
 
     // This loop overshoots by 1, so move back in time by 1
     i0--;
     var i1 = i0 + 1;
 
+    // Toggle usage of request animantion frame

[nduca, 2011/10/10 23:11:19]

I'm struggling to understand this code... and the code above that's looking at
gestures[i0].raf. Is there a cleaner factoring of this?

+    if (new_use_raf != use_raf){
+      use_raf = new_use_raf;
+      __init_raf(use_raf);
+    }
+
     if (i1 < gestures.length) {
       // If i1 exists, interpolate between i0 and i1 y based on time_cur -
       // gestures[i0].time_ms
       var time_since_i0_start = time_cur - gestures[i0].time_ms;
       var time_between_i0_and_i1 = gestures[i1].time_ms -
           gestures[i0].time_ms;
       var percent_into_frame = time_since_i0_start / time_between_i0_and_i1;
       var y_diff_between_i0_and_i1 = gestures[i1].y - gestures[i0].y;
       var interpolated_y = gestures[i0].y +
           (percent_into_frame * y_diff_between_i0_and_i1);
@@ skipping 23 matching lines @@
     y = gestures[i].y + dy;
     gestures.push({
       time_ms: gestures[i].time_ms + dtime_ms,
       y: y,
     });
   }
   return __create_gesture_function(gestures);
 }
 
 function __sched_update() {
-  if (!__raf) {
-    if ("webkitRequestAnimationFrame" in window)
-      __raf = webkitRequestAnimationFrame;
-    else if ("mozRequestAnimationFrame" in window)
-      __raf = mozRequestAnimationFrame;
-  }
   __raf(function() {
     __raf_is_live = true;
+    // In case __raf falls back to using setTimeout, we must schedule the next
+    // update before rendering the current update to help maintain the
+    // regularity of update intervals.
+    __sched_update();
     if (__running) {
-      // Only update the FPS if a gesture movement occurs. Otherwise, the frame
-      // rate average becomes inaccurate after any pause.
-      if (__advance_gesture())
+      // Only update the FPS if a gesture movement or animation occurs.
+      // Otherwise, the frame rate average becomes inaccurate after any pause.
+      var animated = __animation();

[nduca, 2011/10/10 23:11:19]

Is there any merit to this rather than just having the user call raf themselves?

+      if (__advance_gesture() || animated)
         __update_fps();
       else
         __t_last = new Date().getTime();
     }
-    __sched_update();
   }, document.body);
 }
 
 function __start_recording() {
   __start(__advance_gesture_recording);
 }
 
 function __make_body_composited() {
   document.body.style.webkitTransform = "translateZ(0)";
 }
 
 function __start(gesture_function) {
   if (__running)
     return;
+
+  // By default, all gestures start with raf enabled
+  __init_raf(true);

[nduca, 2011/10/10 23:11:19]

We init_raf at the global scope too? Is that one redundant?

+
   // Attempt to create a gesture function from a string name.
   if (typeof gesture_function == "string") {
-    if (!__gestures[gesture_function])
-      throw new Error("Unrecognized gesture name");
+    if (!__gestures[gesture_function]) {
+      if (!__gesture_library[gesture_function])
+        throw new Error("Unrecognized gesture name");
+      else
+        gesture_function = __create_repeating_gesture_function(
+                            __gesture_library[gesture_function]);
+    }
     else
       gesture_function = __create_repeating_gesture_function(
                             __gestures[gesture_function]);
   }
   else if (typeof gesture_function != "function")
     throw new Error("Argument is not a function or gesture name");
 
   __old_title = document.title;
   __advance_gesture = gesture_function;
   __t_start = new Date().getTime();
   __running = true;
   if (!__raf_is_live) {
     __sched_update();
   }
 }
 
 function __start_all() {
   __queued_gesture_functions = [];
   __results = {
     gestures: [],
     means: [],
     sigmas: [],
   };
 
   for (var gesture in __gestures) {
     __results.gestures.push(gesture);
     __queued_gesture_functions.push(gesture);
   }
   __running_all = true;
-  // Run steady gesture once to cache the webpage layout for subsequent tests.
-  __start("steady");
+  // Run init gesture once to cache the webpage layout for subsequent tests.
+  __start("init");

[nduca, 2011/10/10 23:11:19]

Not that this is your fault, but since we're here, do you have a sense of
whether this is this even needed? By the comment, which predates me, I'm
guessing the goal is to force a style recalc/etc by just asking for
document.body.offsetTop

 }
 
 function __stop() {
   __running = false;
   document.title = __old_title;
   window.__scrolledTo = undefined;
 
   if (__running_all) {
     var results = __calc_results();
     __results.means.push(results.mean);
@@ skipping 13 matching lines @@
   __running = false;
   __running_all = false;
   document.title = __old_title;
   document.body.scrollTop = 0;
   __init_stats();
 }
 
 function __force_compositor() {
   document.body.style.webkitTransform = "translateZ(0)";
 }