Allow tasks scheduled for the instant virtual time budges expires to run

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 201 matching lines @@
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
       use_virtual_time(false),
       is_audio_playing(false),
+      virtual_time_suspended(false),
       rail_mode_observer(nullptr),
       wake_up_budget_pool(nullptr),
       task_duration_per_queue_type_histogram(base::Histogram::FactoryGet(
           "RendererScheduler.TaskDurationPerQueueType2",
           1,
           static_cast<int>(TaskQueue::QueueType::COUNT),
           static_cast<int>(TaskQueue::QueueType::COUNT) + 1,
           base::HistogramBase::kUmaTargetedHistogramFlag)) {
   foreground_main_thread_load_tracker.Resume(now);
 }
@@ skipping 131 matching lines @@
   auto insert_result = timer_task_runners_.insert(std::make_pair(
       timer_task_queue, timer_task_queue->CreateQueueEnabledVoter()));
   insert_result.first->second->SetQueueEnabled(
       GetMainThreadOnly().current_policy.timer_queue_policy.is_enabled);
   timer_task_queue->SetQueuePriority(
       GetMainThreadOnly().current_policy.timer_queue_policy.priority);
   if (GetMainThreadOnly().current_policy.timer_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(timer_task_queue.get());
   }
+  if (GetMainThreadOnly().virtual_time_suspended)

[altimin, 2017/05/31 11:44:06]

Is virtual_time_expired a better name?

[alex clarke (OOO till 29th), 2017/05/31 15:11:36]

virtual_time_paused is possibly the most accurate name.

[alex clarke (OOO till 29th), 2017/05/31 16:48:48]

I understand Alexander has a strong preference for _expired due to the budget
however I respectfully disagree. This state is entered when
WebViewSchedulerImpl::allow_virtual_time_to_advance_ is false and
WebViewSchedulerImpl::virtual_time_ is true.  That only happens when we are in
VirtualTimePolicy::PAUSE (hence my preferred name).

Now it is true that the layer above sets the policy to VirtualTimePolicy::PAUSE
when the virtual time budget expires, but that concept doesn't exist at this
level.

[altimin, 2017/05/31 16:51:24]

Yes, it makes sense, thanks for the explanation.

+    timer_task_queue->InsertFence(TaskQueue::InsertFencePosition::NOW);
   timer_task_queue->AddTaskObserver(
       &GetMainThreadOnly().timer_task_cost_estimator);
   AddQueueToWakeUpBudgetPool(timer_task_queue.get());
   return timer_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> unthrottled_task_queue(helper_.NewTaskQueue(
@@ skipping 1023 matching lines @@
   }
 #endif
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   GetMainThreadOnly().timer_queue_suspend_count--;
   DCHECK_GE(GetMainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
 }
 
+void RendererSchedulerImpl::InsertTimerFence() {
+  GetMainThreadOnly().virtual_time_suspended = true;
+  for (const auto& pair : timer_task_runners_) {
+    DCHECK(!task_queue_throttler_->IsThrottled(pair.first.get()));

[altimin, 2017/05/31 11:44:06]

Also DCHECK for not having a fence already and virtual time not being suspended
twice?

[alex clarke (OOO till 29th), 2017/05/31 15:11:36]

Done.

+    pair.first->InsertFence(TaskQueue::InsertFencePosition::NOW);
+  }
+}
+
+void RendererSchedulerImpl::RemoveTimerFence() {
+  GetMainThreadOnly().virtual_time_suspended = false;
+  for (const auto& pair : timer_task_runners_) {
+    DCHECK(!task_queue_throttler_->IsThrottled(pair.first.get()));
+    pair.first->RemoveFence();
+  }
+}
+
 void RendererSchedulerImpl::SetTimerQueueSuspensionWhenBackgroundedEnabled(
     bool enabled) {
   // Note that this will only take effect for the next backgrounded signal.
   GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled =
       enabled;
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValue(base::TimeTicks optional_now) const {
   base::AutoLock lock(any_thread_lock_);
@@ skipping 94 matching lines @@
                     GetAnyThread().default_gesture_prevented);
   state->SetDouble("expected_loading_task_duration",
                    GetMainThreadOnly()
                        .loading_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   state->SetDouble("expected_timer_task_duration",
                    GetMainThreadOnly()
                        .timer_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   state->SetBoolean("is_audio_playing", GetMainThreadOnly().is_audio_playing);
+  state->SetBoolean("virtual_time_suspended",
+                    GetMainThreadOnly().virtual_time_suspended);
 
   state->BeginDictionary("web_view_schedulers");
   for (WebViewSchedulerImpl* web_view_scheduler :
        GetMainThreadOnly().web_view_schedulers) {
     state->BeginDictionaryWithCopiedName(
         trace_helper::PointerToString(web_view_scheduler));
     web_view_scheduler->AsValueInto(state.get());
     state->EndDictionary();
   }
   state->EndDictionary();
@@ skipping 517 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink