Add command-line flag to force compositor framerate.

ui/compositor/compositor.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/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
@@ skipping 48 matching lines @@
 
   // This will ensure PictureLayers always can have LCD text, to match the
   // previous behaviour with ContentLayers, where LCD-not-allowed notifications
   // were ignored.
   settings.layers_always_allowed_lcd_text = true;
   // Use occlusion to allow more overlapping windows to take less memory.
   settings.use_occlusion_for_tile_prioritization = true;
   refresh_rate_ = context_factory_->GetRefreshRate();
   settings.main_frame_before_activation_enabled = false;
 
+  if (command_line->HasSwitch(switches::kLimitFps)) {
+    std::string fps_str =
+        command_line->GetSwitchValueASCII(switches::kLimitFps);
+    double fps;
+    if (base::StringToDouble(fps_str, &fps) && fps > 0) {
+      forced_refresh_rate_ = fps;
+    }
+  }
+
   if (command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders)) {
     std::string layer_borders_string = command_line->GetSwitchValueASCII(
         cc::switches::kUIShowCompositedLayerBorders);
     std::vector<base::StringPiece> entries = base::SplitStringPiece(
         layer_borders_string, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (entries.empty()) {
       settings.initial_debug_state.show_debug_borders.set();
     } else {
       for (const auto& entry : entries) {
         const struct {
@@ skipping 268 matching lines @@
   DCHECK_GT(interval.InMillisecondsF(), 0);
   refresh_rate_ =
       base::Time::kMillisecondsPerSecond / interval.InMillisecondsF();
   if (context_factory_private_)
     context_factory_private_->SetAuthoritativeVSyncInterval(this, interval);
   vsync_manager_->SetAuthoritativeVSyncInterval(interval);
 }
 
 void Compositor::SetDisplayVSyncParameters(base::TimeTicks timebase,
                                            base::TimeDelta interval) {
+  if (forced_refresh_rate_) {
+    timebase = base::TimeTicks();
+    interval = base::TimeDelta::FromSeconds(1) / forced_refresh_rate_;
+  }
   if (interval.is_zero()) {
     // TODO(brianderson): We should not be receiving 0 intervals.
     interval = cc::BeginFrameArgs::DefaultInterval();
   }
   DCHECK_GT(interval.InMillisecondsF(), 0);
   refresh_rate_ =
       base::Time::kMillisecondsPerSecond / interval.InMillisecondsF();
 
   if (context_factory_private_) {
     context_factory_private_->SetDisplayVSyncParameters(this, timebase,
@@ skipping 184 matching lines @@
 void Compositor::TimeoutLocks() {
   // Make a copy, we're going to cause |active_locks_| to become
   // empty.
   std::vector<CompositorLock*> locks = active_locks_;
   for (auto* lock : locks)
     lock->TimeoutLock();
   DCHECK(active_locks_.empty());
 }
 
 }  // namespace ui