cc: Don't double-tick unthrottled FrameRateController

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/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
 };
 
 FrameRateController::FrameRateController(scoped_refptr<TimeSource> timer)
     : client_(NULL),
       num_frames_pending_(0),
       max_swaps_pending_(0),
       interval_(BeginFrameArgs::DefaultInterval()),
       time_source_(timer),
       active_(false),
       is_time_source_throttling_(true),
+      manual_tick_pending_(false),
       task_runner_(NULL),
       weak_factory_(this) {
   time_source_client_adapter_ =
       FrameRateControllerTimeSourceAdapter::Create(this);
   time_source_->SetClient(time_source_client_adapter_.get());
 }
 
 FrameRateController::FrameRateController(
     base::SingleThreadTaskRunner* task_runner)
     : client_(NULL),
       num_frames_pending_(0),
       max_swaps_pending_(0),
       interval_(BeginFrameArgs::DefaultInterval()),
       active_(false),
       is_time_source_throttling_(false),
+      manual_tick_pending_(false),
       task_runner_(task_runner),
       weak_factory_(this) {}
 
 FrameRateController::~FrameRateController() {
   if (is_time_source_throttling_)
     time_source_->SetActive(false);
 }
 
 BeginFrameArgs FrameRateController::SetActive(bool active) {
   if (active_ == active)
     return BeginFrameArgs();
   TRACE_EVENT1("cc", "FrameRateController::SetActive", "active", active);
   active_ = active;
 
   if (is_time_source_throttling_) {
     base::TimeTicks missed_tick_time = time_source_->SetActive(active);
     if (!missed_tick_time.is_null()) {
       base::TimeTicks deadline = NextTickTime();
       return  BeginFrameArgs::Create(
           missed_tick_time, deadline + deadline_adjustment_, interval_);
     }
   } else {
-    if (active)
+    if (active) {
       PostManualTick();
-    else
+    } else {
       weak_factory_.InvalidateWeakPtrs();
+      manual_tick_pending_ = false;
+    }
   }
 
   return BeginFrameArgs();
 }
 
 void FrameRateController::SetMaxSwapsPending(int max_swaps_pending) {
   DCHECK_GE(max_swaps_pending, 0);
   max_swaps_pending_ = max_swaps_pending;
 }
 
@@ skipping 24 matching lines @@
     BeginFrameArgs args = BeginFrameArgs::Create(
         frame_time, deadline + deadline_adjustment_, interval_);
     client_->FrameRateControllerTick(throttled, args);
   }
 
   if (!is_time_source_throttling_ && !throttled)
     PostManualTick();
 }
 
 void FrameRateController::PostManualTick() {
-  if (active_) {
+  if (active_ && !manual_tick_pending_) {
+    manual_tick_pending_ = true;
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&FrameRateController::ManualTick,
                                       weak_factory_.GetWeakPtr()));
   }
 }
 
 void FrameRateController::ManualTick() {
+  manual_tick_pending_ = false;
   OnTimerTick();
 }
 
 void FrameRateController::DidSwapBuffers() {
   num_frames_pending_++;
 }
 
 void FrameRateController::DidSwapBuffersComplete() {
   DCHECK_GT(num_frames_pending_, 0);
   num_frames_pending_--;
@@ skipping 13 matching lines @@
 }
 
 base::TimeTicks FrameRateController::LastTickTime() {
   if (is_time_source_throttling_)
     return time_source_->LastTickTime();
 
   return gfx::FrameTime::Now();
 }
 
 }  // namespace cc