[scheduler] Report background timer throttling intervention.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc

 // Copyright 2015 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 "platform/scheduler/renderer/task_queue_throttler.h"
 
 #include <cstdint>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 140 matching lines @@
   }
 
   // TODO(altimin): We need to disable TimeBudgetQueues here or they will
   // regenerate extra time budget when they are disabled.
 }
 
 bool TaskQueueThrottler::TimeBudgetPool::IsThrottlingEnabled() const {
   return is_enabled_;
 }
 
+void TaskQueueThrottler::TimeBudgetPool::SetReportingCallback(
+    base::Callback<void(base::TimeDelta)> reporting_callback) {
+  reporting_callback_ = reporting_callback;
+}
+
 void TaskQueueThrottler::TimeBudgetPool::Close() {
   DCHECK_EQ(0u, associated_task_queues_.size());
 
   task_queue_throttler_->time_budget_pools_.erase(this);
 }
 
 bool TaskQueueThrottler::TimeBudgetPool::HasEnoughBudgetToRun(
     base::TimeTicks now) {
   Advance(now);
   return !is_enabled_ || current_budget_level_.InMicroseconds() >= 0;
 }
 
 base::TimeTicks TaskQueueThrottler::TimeBudgetPool::GetNextAllowedRunTime() {
   if (!is_enabled_ || current_budget_level_.InMicroseconds() >= 0) {
     return last_checkpoint_;
   } else {
     // Subtract because current_budget is negative.
     return last_checkpoint_ - current_budget_level_ / cpu_percentage_;
   }
 }
 
 void TaskQueueThrottler::TimeBudgetPool::RecordTaskRunTime(
     base::TimeTicks start_time,
     base::TimeTicks end_time) {
   DCHECK_LE(start_time, end_time);
   Advance(end_time);
   if (is_enabled_) {
+    base::TimeDelta old_budget_level = current_budget_level_;
     current_budget_level_ -= (end_time - start_time);
     EnforceBudgetLevelRestrictions();
+
+    if (!reporting_callback_.is_null() && old_budget_level.InSecondsF() > 0 &&
+        current_budget_level_.InSecondsF() < 0) {
+      reporting_callback_.Run(-current_budget_level_ / cpu_percentage_);

[Sami, 2016/11/08 19:05:08]

nit: Is forgot if calling a null callback is a no-op or not? If it's a no-op, we
could just remove the null check since this is always gonna be there in
production code.

[altimin, 2016/11/08 19:08:47]

It's a failure, unfortunately.

+    }
   }
 }
 
 const char* TaskQueueThrottler::TimeBudgetPool::Name() const {
   return name_;
 }
 
 void TaskQueueThrottler::TimeBudgetPool::AsValueInto(
     base::trace_event::TracedValue* state,
     base::TimeTicks now) const {
@@ skipping 415 matching lines @@
 
     queue->SetQueueEnabled(false);
     queue->SetTimeDomain(time_domain_.get());
     MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
                            GetNextAllowedRunTime(lazy_now.Now(), queue));
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink