Move disable_display_vsync out of RendererSettings

cc/test/test_compositor_frame_sink.cc

 // Copyright 2016 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 "cc/test/test_compositor_frame_sink.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_sink_client.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 
 namespace cc {
 
 static constexpr FrameSinkId kCompositorFrameSinkId(1, 1);
 
 TestCompositorFrameSink::TestCompositorFrameSink(
     scoped_refptr<ContextProvider> compositor_context_provider,
     scoped_refptr<ContextProvider> worker_context_provider,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     const RendererSettings& renderer_settings,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    bool synchronous_composite)
+    bool synchronous_composite,
+    bool disable_display_vsync)
     : CompositorFrameSink(std::move(compositor_context_provider),
                           std::move(worker_context_provider),
                           gpu_memory_buffer_manager,
                           shared_bitmap_manager),
       synchronous_composite_(synchronous_composite),
+      disable_display_vsync_(disable_display_vsync),
       renderer_settings_(renderer_settings),
       task_runner_(std::move(task_runner)),
       frame_sink_id_(kCompositorFrameSinkId),
       surface_manager_(new SurfaceManager),
       local_surface_id_allocator_(new LocalSurfaceIdAllocator()),
       external_begin_frame_source_(this),
       weak_ptr_factory_(this) {
   // Always use sync tokens so that code paths in resource provider that deal
   // with sync tokens are tested.
   capabilities_.delegated_sync_points_required = true;
@@ skipping 12 matching lines @@
   if (!CompositorFrameSink::BindToClient(client))
     return false;
 
   std::unique_ptr<OutputSurface> display_output_surface =
       test_client_->CreateDisplayOutputSurface(context_provider());
   bool display_context_shared_with_compositor =
       display_output_surface->context_provider() == context_provider();
 
   std::unique_ptr<DisplayScheduler> scheduler;
   if (!synchronous_composite_) {
-    if (renderer_settings_.disable_display_vsync) {
+    if (disable_display_vsync_) {
       begin_frame_source_.reset(new BackToBackBeginFrameSource(
           base::MakeUnique<DelayBasedTimeSource>(task_runner_.get())));
     } else {
       begin_frame_source_.reset(new DelayBasedBeginFrameSource(
           base::MakeUnique<DelayBasedTimeSource>(task_runner_.get())));
       begin_frame_source_->SetAuthoritativeVSyncInterval(
           base::TimeDelta::FromMilliseconds(1000.f /
                                             renderer_settings_.refresh_rate));
     }
     scheduler.reset(new DisplayScheduler(
@@ skipping 116 matching lines @@
   support_->SetNeedsBeginFrame(needs_begin_frames);
 }
 
 void TestCompositorFrameSink::OnDidFinishFrame(const BeginFrameAck& ack) {}
 
 void TestCompositorFrameSink::SendCompositorFrameAckToClient() {
   client_->DidReceiveCompositorFrameAck();
 }
 
 }  // namespace cc