Move disable_display_vsync out of RendererSettings

content/browser/compositor/gpu_process_transport_factory.cc

 // Copyright 2014 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/browser/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 181 matching lines @@
 
 GpuProcessTransportFactory::GpuProcessTransportFactory()
     : frame_sink_id_allocator_(kDefaultClientId),
       task_graph_runner_(new cc::SingleThreadTaskGraphRunner),
       callback_factory_(this) {
   cc::SetClientNameForMetrics("Browser");
 
   frame_sink_manager_host_ = base::MakeUnique<FrameSinkManagerHost>();
   frame_sink_manager_host_->ConnectToFrameSinkManager();
 
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDisableGpuVsync)) {
+    std::string display_vsync_string =
+        command_line->GetSwitchValueASCII(switches::kDisableGpuVsync);
+    // See comments in gl_switches about this flag.  The browser compositor
+    // is only unthrottled when "gpu" or no switch value is passed, as it
+    // is driven directly by the display compositor.
+    if (display_vsync_string != "beginframe") {
+      disable_display_vsync_ = true;
+    }
+  }
+
   task_graph_runner_->Start("CompositorTileWorker1",
                             base::SimpleThread::Options());
 #if defined(OS_WIN)
   software_backing_.reset(new OutputDeviceBacking);
 #endif
 }
 
 GpuProcessTransportFactory::~GpuProcessTransportFactory() {
   DCHECK(per_compositor_data_.empty());
 
@@ skipping 332 matching lines @@
   }
 
   data->display_output_surface = display_output_surface.get();
   if (data->reflector)
     data->reflector->OnSourceSurfaceReady(data->display_output_surface);
 
   std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source;
   std::unique_ptr<GpuVSyncBeginFrameSource> gpu_vsync_begin_frame_source;
 
   if (!begin_frame_source) {
-    if (!compositor->GetRendererSettings().disable_display_vsync) {
+    if (!disable_display_vsync_) {
       if (gpu_vsync_control && IsGpuVSyncSignalSupported()) {
         gpu_vsync_begin_frame_source =
             base::MakeUnique<GpuVSyncBeginFrameSource>(gpu_vsync_control);
         begin_frame_source = gpu_vsync_begin_frame_source.get();
       } else {
         synthetic_begin_frame_source =
             base::MakeUnique<cc::DelayBasedBeginFrameSource>(
                 base::MakeUnique<cc::DelayBasedTimeSource>(
                     compositor->task_runner().get()));
         begin_frame_source = synthetic_begin_frame_source.get();
@@ skipping 366 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content