VDA: Don't wait for the VSyncProvider in headless mode

content/common/gpu/media/rendering_helper.cc

 // Copyright 2013 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/common/gpu/media/rendering_helper.h"
 
 #include <algorithm>
 #include <numeric>
 #include <vector>
 
@@ skipping 163 matching lines @@
                               gfx::kGLImplementationDesktopName);
 #else
   cmd_line->AppendSwitchASCII(switches::kUseGL, gfx::kGLImplementationEGLName);
 #endif
 
   if (!gfx::GLSurface::InitializeOneOff())
     LOG(FATAL) << "Could not initialize GL";
   done->Signal();
 }
 
-RenderingHelper::RenderingHelper() {
+RenderingHelper::RenderingHelper() : ignore_vsync_(false) {
   window_ = gfx::kNullAcceleratedWidget;
   Clear();
 }
 
 RenderingHelper::~RenderingHelper() {
   CHECK_EQ(videos_.size(), 0U) << "Must call UnInitialize before dtor.";
   Clear();
 }
 
 void RenderingHelper::Setup() {
@@ skipping 39 matching lines @@
   XSelectInput(display, window_, ExposureMask);
   XMapWindow(display, window_);
 #elif defined(USE_OZONE)
   base::MessageLoop::ScopedNestableTaskAllower nest_loop(
       base::MessageLoop::current());
   base::RunLoop wait_window_resize;
 
   platform_window_delegate_.reset(new RenderingHelper::StubOzoneDelegate());
   window_ = platform_window_delegate_->accelerated_widget();
   gfx::Size window_size(800, 600);
+  // Assume headless mode by default. On ChromeOS this will be set accordingly

[Pawel Osciak, 2015/04/24 01:08:56]

Please update comment.

[dnicoara, 2015/04/24 13:21:12]

Done.

+  // based on the display configuration.
+  ignore_vsync_ = true;
 #if defined(OS_CHROMEOS)
   // We hold onto the main loop here to wait for the DisplayController
   // to give us the size of the display so we can create a window of
   // the same size.
   base::RunLoop wait_display_setup;
   DisplayConfiguratorObserver display_setup_observer(&wait_display_setup);
   display_configurator_.reset(new ui::DisplayConfigurator());
   display_configurator_->SetDelegateForTesting(0);
   display_configurator_->AddObserver(&display_setup_observer);
   display_configurator_->Init(true);
   display_configurator_->ForceInitialConfigure(0);
   // Make sure all the display configuration is applied.
   wait_display_setup.Run();
   display_configurator_->RemoveObserver(&display_setup_observer);
 
   gfx::Size framebuffer_size = display_configurator_->framebuffer_size();
-  if (!framebuffer_size.IsEmpty())
+  if (!framebuffer_size.IsEmpty()) {
     window_size = framebuffer_size;
+    ignore_vsync_ = false;
+  }
 #endif
+  if (ignore_vsync_)
+    DVLOG(1) << "Ignoring vsync provider";
+
   platform_window_delegate_->platform_window()->SetBounds(
       gfx::Rect(window_size));
 
   // On Ozone/DRI, platform windows are associated with the physical
   // outputs. Association is achieved by matching the bounds of the
   // window with the origin & modeset of the display output. Until a
   // window is associated with a display output, we cannot get vsync
   // events, because there is no hardware to get events from. Here we
   // wait for the window to resized and therefore associated with
   // display output to be sure that we will get such events.
@@ skipping 191 matching lines @@
     // the front and back buffers.
     warm_up_iterations = std::max(2, warm_up_iterations);
 #endif
     WarmUpRendering(warm_up_iterations);
   }
 
   // It's safe to use Unretained here since |rendering_thread_| will be stopped
   // in VideoDecodeAcceleratorTest.TearDown(), while the |rendering_helper_| is
   // a member of that class. (See video_decode_accelerator_unittest.cc.)
   gfx::VSyncProvider* vsync_provider = gl_surface_->GetVSyncProvider();
-  if (vsync_provider && frame_duration_ != base::TimeDelta())
+
+  // VSync providers rely on the underlying CRTC to get the timing. In headless
+  // mode the surface isn't associated with a CRTC so the vsync provider can not
+  // get the timing, meaning it will not call UpdateVsyncParameters() ever.
+  if (!ignore_vsync_ && vsync_provider && frame_duration_ != base::TimeDelta())
     vsync_provider->GetVSyncParameters(base::Bind(
         &RenderingHelper::UpdateVSyncParameters, base::Unretained(this), done));
   else
     done->Signal();
 }
 
 // The rendering for the first few frames is slow (e.g., 100ms on Peach Pit).
 // This affects the numbers measured in the performance test. We try to render
 // several frames here to warm up the rendering.
 void RenderingHelper::WarmUpRendering(int warm_up_iterations) {
@@ skipping 211 matching lines @@
 
 void RenderingHelper::RenderContent() {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   // Update the VSync params.
   //
   // It's safe to use Unretained here since |rendering_thread_| will be stopped
   // in VideoDecodeAcceleratorTest.TearDown(), while the |rendering_helper_| is
   // a member of that class. (See video_decode_accelerator_unittest.cc.)
   gfx::VSyncProvider* vsync_provider = gl_surface_->GetVSyncProvider();
-  if (vsync_provider) {
+  if (vsync_provider && !ignore_vsync_) {
     vsync_provider->GetVSyncParameters(base::Bind(
         &RenderingHelper::UpdateVSyncParameters, base::Unretained(this),
         static_cast<base::WaitableEvent*>(NULL)));
   }
 
   int tex_flip = 1;
 #if defined(USE_OZONE)
   // Ozone surfaceless renders flipped from normal GL, so there's no need to
   // do an extra flip.
   tex_flip = 0;
@@ skipping 131 matching lines @@
   // When the rendering falls behind, drops frames.
   while (scheduled_render_time_ < target) {
     scheduled_render_time_ += frame_duration_;
     DropOneFrameForAllVideos();
   }
 
   message_loop_->PostDelayedTask(
       FROM_HERE, render_task_.callback(), target - now);
 }
 }  // namespace content