cc: Emulate BeginFrame in OutputSurfaces that don't support it natively

cc/scheduler/frame_rate_controller.cc

 // Copyright 2011 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/scheduler/frame_rate_controller.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "cc/base/thread.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/time_source.h"
 
 namespace cc {
 
 class FrameRateControllerTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<FrameRateControllerTimeSourceAdapter> Create(
       FrameRateController* frame_rate_controller) {
     return make_scoped_ptr(
         new FrameRateControllerTimeSourceAdapter(frame_rate_controller));
   }
   virtual ~FrameRateControllerTimeSourceAdapter() {}
 
-  virtual void OnTimerTick() OVERRIDE { frame_rate_controller_->OnTimerTick(); }
+  virtual void OnTimerTick() OVERRIDE {
+    frame_rate_controller_->OnTimerTick();
+  }
 
  private:
   explicit FrameRateControllerTimeSourceAdapter(
       FrameRateController* frame_rate_controller)
       : frame_rate_controller_(frame_rate_controller) {}
 
   FrameRateController* frame_rate_controller_;
 };
 
 FrameRateController::FrameRateController(scoped_refptr<TimeSource> timer)
@@ skipping 51 matching lines @@
                                                  base::TimeDelta interval) {
   if (is_time_source_throttling_)
     time_source_->SetTimebaseAndInterval(timebase, interval);
 }
 
 void FrameRateController::SetSwapBuffersCompleteSupported(bool supported) {
   swap_buffers_complete_supported_ = supported;
 }
 
 void FrameRateController::OnTimerTick() {
+  TRACE_EVENT0("cc", "FrameRateController::OnTimerTick");
   DCHECK(active_);
 
   // Check if we have too many frames in flight.
   bool throttled =
       max_frames_pending_ && num_frames_pending_ >= max_frames_pending_;
   TRACE_COUNTER_ID1("cc", "ThrottledCompositor", thread_, throttled);
 
-  if (client_)
-    client_->BeginFrame(throttled);
+  if (client_) {
+    client_->FrameRateControllerTick(throttled);
+  }
 
   if (swap_buffers_complete_supported_ && !is_time_source_throttling_ &&
       !throttled)
     PostManualTick();
 }
 
 void FrameRateController::PostManualTick() {
   if (active_) {
     thread_->PostTask(base::Bind(&FrameRateController::ManualTick,
                                  weak_factory_.GetWeakPtr()));
   }
 }
 
-void FrameRateController::ManualTick() { OnTimerTick(); }
+void FrameRateController::ManualTick() {
+  OnTimerTick();
+}
 
-void FrameRateController::DidSwapBuffers() {
+void FrameRateController::WillSwapBuffers() {

[brianderson, 2013/06/01 04:30:29]

This now corresponds to a BeginFrame rather than a Swap which is why I call it
WillSwapBuffers now.

   if (swap_buffers_complete_supported_)
     num_frames_pending_++;
   else if (!is_time_source_throttling_)
     PostManualTick();
 }
 
 void FrameRateController::DidSwapBuffersComplete() {
   DCHECK(swap_buffers_complete_supported_);
 
   DCHECK_GT(num_frames_pending_, 0);
@@ skipping 14 matching lines @@
 }
 
 base::TimeTicks FrameRateController::LastTickTime() {
   if (is_time_source_throttling_)
     return time_source_->LastTickTime();
 
   return base::TimeTicks::Now();
 }
 
 }  // namespace cc