Hook up ui::Compositor to Display's BeginFrameSource

content/browser/compositor/browser_compositor_output_surface.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/browser_compositor_output_surface.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/base/switches.h"
+#include "cc/output/output_surface_client.h"
 #include "content/browser/compositor/browser_compositor_overlay_candidate_validator.h"
 #include "content/browser/compositor/reflector_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 
 namespace content {
 
 BrowserCompositorOutputSurface::BrowserCompositorOutputSurface(
     const scoped_refptr<cc::ContextProvider>& context_provider,
     const scoped_refptr<cc::ContextProvider>& worker_context_provider,
     const scoped_refptr<ui::CompositorVSyncManager>& vsync_manager,
+    base::SingleThreadTaskRunner* task_runner,
     scoped_ptr<BrowserCompositorOverlayCandidateValidator>
         overlay_candidate_validator)
     : OutputSurface(context_provider, worker_context_provider),
       vsync_manager_(vsync_manager),
+      synthetic_begin_frame_source_(new cc::SyntheticBeginFrameSource(
+          task_runner,
+          cc::BeginFrameArgs::DefaultInterval())),
       reflector_(nullptr),
       use_begin_frame_scheduling_(
-          base::CommandLine::ForCurrentProcess()
-              ->HasSwitch(cc::switches::kEnableBeginFrameScheduling)) {
+          base::CommandLine::ForCurrentProcess()->HasSwitch(
+              cc::switches::kEnableBeginFrameScheduling)) {
   overlay_candidate_validator_ = std::move(overlay_candidate_validator);
   Initialize();
 }
 
 BrowserCompositorOutputSurface::BrowserCompositorOutputSurface(
     scoped_ptr<cc::SoftwareOutputDevice> software_device,
-    const scoped_refptr<ui::CompositorVSyncManager>& vsync_manager)
+    const scoped_refptr<ui::CompositorVSyncManager>& vsync_manager,
+    base::SingleThreadTaskRunner* task_runner)
     : OutputSurface(std::move(software_device)),
       vsync_manager_(vsync_manager),
+      synthetic_begin_frame_source_(new cc::SyntheticBeginFrameSource(
+          task_runner,
+          cc::BeginFrameArgs::DefaultInterval())),
       reflector_(nullptr),
       use_begin_frame_scheduling_(
-          base::CommandLine::ForCurrentProcess()
-              ->HasSwitch(cc::switches::kEnableBeginFrameScheduling)) {
+          base::CommandLine::ForCurrentProcess()->HasSwitch(
+              cc::switches::kEnableBeginFrameScheduling)) {

[sunnyps, 2016/04/01 22:35:25]

nit: Is this flag ever false? If not can you remove it?

[enne (OOO), 2016/04/02 00:18:38]

Yes.  This flag is sometimes false.  That boolean is used to sometimes send
vsync information to the renderer when it is false.  That vsync path can't be
removed until all the renderers are using begin frame scheduling, unfortunately.

   Initialize();
 }
 
 BrowserCompositorOutputSurface::~BrowserCompositorOutputSurface() {
   if (reflector_)
     reflector_->DetachFromOutputSurface();
   DCHECK(!reflector_);
   if (!HasClient())
     return;
 
   // When BeginFrame scheduling is enabled, vsync info is not routed to renderer
   // by using |vsync_manager_|. Instead, BeginFrame message is used.
   if (!use_begin_frame_scheduling_)
     vsync_manager_->RemoveObserver(this);
 }
 
 void BrowserCompositorOutputSurface::Initialize() {
   capabilities_.adjust_deadline_for_parent = false;
 }
 
 bool BrowserCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* client) {
   if (!OutputSurface::BindToClient(client))
     return false;
 
+  // Pass begin frame source up to Display to use for DisplayScheduler.
+  client->SetBeginFrameSource(synthetic_begin_frame_source_.get());
+
   // Don't want vsync notifications until there is a client.
   if (!use_begin_frame_scheduling_)
     vsync_manager_->AddObserver(this);
   return true;
 }
 
+void BrowserCompositorOutputSurface::UpdateVSyncParametersInternal(
+    base::TimeTicks timebase,
+    base::TimeDelta interval) {
+  if (interval == base::TimeDelta()) {
+    // TODO(brianderson): We should not be receiving 0 intervals.
+    interval = cc::BeginFrameArgs::DefaultInterval();
+  }
+  synthetic_begin_frame_source_->OnUpdateVSyncParameters(timebase, interval);
+
+  // TODO(enne): remove this once vsyncs are no longer used in the renderer.
+  CommitVSyncParameters(timebase, interval);
+}
+
 void BrowserCompositorOutputSurface::OnUpdateVSyncParameters(
     base::TimeTicks timebase,
     base::TimeDelta interval) {
   DCHECK(HasClient());
   DCHECK(!use_begin_frame_scheduling_);
-  CommitVSyncParameters(timebase, interval);
+  UpdateVSyncParametersInternal(timebase, interval);
 }
 
 void BrowserCompositorOutputSurface::OnUpdateVSyncParametersFromGpu(
     base::TimeTicks timebase,
     base::TimeDelta interval) {
   DCHECK(HasClient());
   if (use_begin_frame_scheduling_) {
-    CommitVSyncParameters(timebase, interval);
+    UpdateVSyncParametersInternal(timebase, interval);
     return;
   }
 
   vsync_manager_->UpdateVSyncParameters(timebase, interval);
 }
 
 void BrowserCompositorOutputSurface::SetReflector(ReflectorImpl* reflector) {
   // Software mirroring is done by doing a GL copy out of the framebuffer - if
   // we have overlays then that data will be missing.
   if (overlay_candidate_validator_) {
@@ skipping 11 matching lines @@
 BrowserCompositorOutputSurface::CreateCompositionStartedCallback() {
   return base::Closure();
 }
 
 cc::OverlayCandidateValidator*
 BrowserCompositorOutputSurface::GetOverlayCandidateValidator() const {
   return overlay_candidate_validator_.get();
 }
 
 }  // namespace content