cc: Move scheduling logic out of OutputSurface

cc/output/output_surface.cc

 // Copyright (c) 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 "cc/output/output_surface.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 26 matching lines @@
 namespace {
 
 const size_t kGpuLatencyHistorySize = 60;
 const double kGpuLatencyEstimationPercentile = 100.0;
 
 }
 
 namespace cc {
 
 OutputSurface::OutputSurface(scoped_refptr<ContextProvider> context_provider)
-    : context_provider_(context_provider),
+    : client_(NULL),
+      context_provider_(context_provider),
       device_scale_factor_(-1),
-      begin_frame_interval_(BeginFrameArgs::DefaultInterval()),
-      throttle_frame_production_(true),
-      needs_begin_frame_(false),
-      client_ready_for_begin_frame_(true),
-      client_(NULL),
-      check_for_retroactive_begin_frame_pending_(false),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
-      gpu_latency_history_(kGpuLatencyHistorySize) {}
+      gpu_latency_history_(kGpuLatencyHistorySize) {
+}
 
 OutputSurface::OutputSurface(scoped_ptr<SoftwareOutputDevice> software_device)
-    : software_device_(software_device.Pass()),
+    : client_(NULL),
+      software_device_(software_device.Pass()),
       device_scale_factor_(-1),
-      begin_frame_interval_(BeginFrameArgs::DefaultInterval()),
-      throttle_frame_production_(true),
-      needs_begin_frame_(false),
-      client_ready_for_begin_frame_(true),
-      client_(NULL),
-      check_for_retroactive_begin_frame_pending_(false),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
-      gpu_latency_history_(kGpuLatencyHistorySize) {}
+      gpu_latency_history_(kGpuLatencyHistorySize) {
+}
 
 OutputSurface::OutputSurface(scoped_refptr<ContextProvider> context_provider,
                              scoped_ptr<SoftwareOutputDevice> software_device)
-    : context_provider_(context_provider),
+    : client_(NULL),
+      context_provider_(context_provider),
       software_device_(software_device.Pass()),
       device_scale_factor_(-1),
-      begin_frame_interval_(BeginFrameArgs::DefaultInterval()),
-      throttle_frame_production_(true),
-      needs_begin_frame_(false),
-      client_ready_for_begin_frame_(true),
-      client_(NULL),
-      check_for_retroactive_begin_frame_pending_(false),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
-      gpu_latency_history_(kGpuLatencyHistorySize) {}
-
-void OutputSurface::SetThrottleFrameProduction(bool enable) {
-  DCHECK(!frame_rate_controller_);
-  throttle_frame_production_ = enable;
-}
-
-void OutputSurface::InitializeBeginFrameEmulation(
-    base::SingleThreadTaskRunner* task_runner,
-    base::TimeDelta interval) {
-  DCHECK(throttle_frame_production_);
-  scoped_refptr<DelayBasedTimeSource> time_source;
-  if (gfx::FrameTime::TimestampsAreHighRes())
-    time_source = DelayBasedTimeSourceHighRes::Create(interval, task_runner);
-  else
-    time_source = DelayBasedTimeSource::Create(interval, task_runner);
-  frame_rate_controller_.reset(new FrameRateController(time_source));
-
-  frame_rate_controller_->SetClient(this);
-  frame_rate_controller_->SetDeadlineAdjustment(
-      capabilities_.adjust_deadline_for_parent ?
-          BeginFrameArgs::DefaultDeadlineAdjustment() : base::TimeDelta());
+      gpu_latency_history_(kGpuLatencyHistorySize) {
 }
 
 void OutputSurface::CommitVSyncParameters(base::TimeTicks timebase,
                                           base::TimeDelta interval) {
   TRACE_EVENT2("cc",
                "OutputSurface::CommitVSyncParameters",
                "timebase",
                (timebase - base::TimeTicks()).InSecondsF(),
                "interval",
                interval.InSecondsF());
-  begin_frame_interval_ = interval;
-  if (frame_rate_controller_)
-    frame_rate_controller_->SetTimebaseAndInterval(timebase, interval);
-}
-
-void OutputSurface::FrameRateControllerTick(const BeginFrameArgs& args) {
-  DCHECK(frame_rate_controller_);
-  BeginFrame(args);
+  client_->CommitVSyncParameters(timebase, interval);
 }
 
 // Forwarded to OutputSurfaceClient
 void OutputSurface::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "OutputSurface::SetNeedsRedrawRect");
   client_->SetNeedsRedrawRect(damage_rect);
 }
 
-void OutputSurface::SetNeedsBeginFrame(bool enable) {
-  TRACE_EVENT1("cc", "OutputSurface::SetNeedsBeginFrame", "enable", enable);
-  needs_begin_frame_ = enable;
-  client_ready_for_begin_frame_ = true;
-  if (!throttle_frame_production_) {
-    if (enable) {
-      base::TimeTicks frame_time = gfx::FrameTime::Now();
-      base::TimeTicks deadline = frame_time + begin_frame_interval_;
-      skipped_begin_frame_args_ =
-          BeginFrameArgs::Create(frame_time, deadline, begin_frame_interval_);
-    }
-  } else if (frame_rate_controller_) {
-    BeginFrameArgs skipped = frame_rate_controller_->SetActive(enable);
-    if (skipped.IsValid())
-      skipped_begin_frame_args_ = skipped;
-  }
-
-  if (needs_begin_frame_)
-    PostCheckForRetroactiveBeginFrame();
-}
-
-void OutputSurface::BeginFrame(const BeginFrameArgs& args) {
-  TRACE_EVENT1("cc",
-               "OutputSurface::BeginFrame",
-               "client_ready_for_begin_frame_",
-               client_ready_for_begin_frame_);
-  if (!needs_begin_frame_ || !client_ready_for_begin_frame_) {
-    skipped_begin_frame_args_ = args;
-  } else {
-    client_ready_for_begin_frame_ = false;
-    client_->BeginFrame(args);
-    // args might be an alias for skipped_begin_frame_args_.
-    // Do not reset it before calling BeginFrame!
-    skipped_begin_frame_args_ = BeginFrameArgs();
-  }
-}
-
-base::TimeTicks OutputSurface::RetroactiveBeginFrameDeadline() {
-  // TODO(brianderson): Remove the alternative deadline once we have better
-  // deadline estimations.
-  base::TimeTicks alternative_deadline =
-      skipped_begin_frame_args_.frame_time +
-      BeginFrameArgs::DefaultRetroactiveBeginFramePeriod();
-  return std::max(skipped_begin_frame_args_.deadline, alternative_deadline);
-}
-
-void OutputSurface::PostCheckForRetroactiveBeginFrame() {
-  if (!skipped_begin_frame_args_.IsValid() ||
-      check_for_retroactive_begin_frame_pending_)
-    return;
-
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&OutputSurface::CheckForRetroactiveBeginFrame,
-                 weak_ptr_factory_.GetWeakPtr()));
-  check_for_retroactive_begin_frame_pending_ = true;
-}
-
-void OutputSurface::CheckForRetroactiveBeginFrame() {
-  TRACE_EVENT0("cc", "OutputSurface::CheckForRetroactiveBeginFrame");
-  check_for_retroactive_begin_frame_pending_ = false;
-  if (!throttle_frame_production_ ||
-      gfx::FrameTime::Now() < RetroactiveBeginFrameDeadline())
-    BeginFrame(skipped_begin_frame_args_);
-}
-
-void OutputSurface::DidSwapBuffers() {
-  TRACE_EVENT0("cc", "OutputSurface::DidSwapBuffers");
-  client_->DidSwapBuffers();
-}
-
-void OutputSurface::OnSwapBuffersComplete() {
-  TRACE_EVENT0("cc", "OutputSurface::OnSwapBuffersComplete");
-  client_->DidSwapBuffersComplete();
-}
-
 void OutputSurface::ReclaimResources(const CompositorFrameAck* ack) {
   client_->ReclaimResources(ack);
 }
 
 void OutputSurface::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "OutputSurface::DidLoseOutputSurface");
-  client_ready_for_begin_frame_ = true;
-  skipped_begin_frame_args_ = BeginFrameArgs();
-  if (frame_rate_controller_)
-    frame_rate_controller_->SetActive(false);
   pending_gpu_latency_query_ids_.clear();
   available_gpu_latency_query_ids_.clear();
   client_->DidLoseOutputSurface();
 }
 
 void OutputSurface::SetExternalStencilTest(bool enabled) {
   external_stencil_test_enabled_ = enabled;
 }
 
 void OutputSurface::SetExternalDrawConstraints(const gfx::Transform& transform,
                                                const gfx::Rect& viewport,
                                                const gfx::Rect& clip,
                                                bool valid_for_tile_management) {
   client_->SetExternalDrawConstraints(
       transform, viewport, clip, valid_for_tile_management);
 }
 
 OutputSurface::~OutputSurface() {
-  if (frame_rate_controller_)
-    frame_rate_controller_->SetActive(false);
   ResetContext3d();
 }
 
 bool OutputSurface::HasExternalStencilTest() const {
   return external_stencil_test_enabled_;
 }
 
 bool OutputSurface::ForcedDrawToSoftwareDevice() const { return false; }
 
 bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
@@ skipping 109 matching lines @@
 }
 
 void OutputSurface::BindFramebuffer() {
   DCHECK(context_provider_);
   context_provider_->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 void OutputSurface::SwapBuffers(CompositorFrame* frame) {
   if (frame->software_frame_data) {
     PostSwapBuffersComplete();
-    DidSwapBuffers();
+    client_->DidSwapBuffers();
     return;
   }
 
   DCHECK(context_provider_);
   DCHECK(frame->gl_frame_data);
 
   UpdateAndMeasureGpuLatency();
   if (frame->gl_frame_data->sub_buffer_rect ==
       gfx::Rect(frame->gl_frame_data->size)) {
     context_provider_->ContextSupport()->Swap();
   } else {
     context_provider_->ContextSupport()->PartialSwapBuffers(
         frame->gl_frame_data->sub_buffer_rect);
   }
 
-  DidSwapBuffers();
+  client_->DidSwapBuffers();
 }
 
 base::TimeDelta OutputSurface::GpuLatencyEstimate() {
   if (context_provider_ && !capabilities_.adjust_deadline_for_parent)
     return gpu_latency_history_.Percentile(kGpuLatencyEstimationPercentile);
   else
     return base::TimeDelta();
 }
 
 void OutputSurface::UpdateAndMeasureGpuLatency() {
@@ skipping 62 matching lines @@
 #endif
 }
 
 void OutputSurface::PostSwapBuffersComplete() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&OutputSurface::OnSwapBuffersComplete,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void OutputSurface::OnSwapBuffersComplete() {

[piman, 2014/04/24 20:27:56]

nit: Is anything using this? I think most (all?) derived classes were changed to
call the client directly. Either remove, or make all derived classes consistent
by calling this?

[brianderson, 2014/04/24 21:33:43]

I initially got rid of this method, but put it back because I was worried about
posting a task bound to the client, which might outlive this OutputSurface,
making it possible for a SwapBuffersComplete for an old OutputSurface to arrive
after the new OutputSurface is created.

With this method, we can post a task with a weak pointer to the OutputSurface
that will automatically cancel any pending calls.

I'll add a comment explaining why this method exists since it isn't clear.

+  client_->DidSwapBuffersComplete();
+}
+
 void OutputSurface::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   TRACE_EVENT1("cc", "OutputSurface::SetMemoryPolicy",
                "bytes_limit_when_visible", policy.bytes_limit_when_visible);
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (policy.bytes_limit_when_visible)
     client_->SetMemoryPolicy(policy);
 }
 
 }  // namespace cc