scheduler: Don't block expensive loading tasks during main thread gestures

components/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 "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 592 matching lines @@
 
   if (new_policy_duration > base::TimeDelta()) {
     MainThreadOnly().current_policy_expiration_time = now + new_policy_duration;
     delayed_update_policy_runner_.SetDeadline(FROM_HERE, new_policy_duration,
                                               now);
   } else {
     MainThreadOnly().current_policy_expiration_time = base::TimeTicks();
   }
 
   Policy new_policy;
-  bool block_expensive_tasks = false;
+  bool block_expensive_loading_tasks = false;
+  bool block_expensive_timer_tasks = false;
   switch (use_case) {
     case UseCase::COMPOSITOR_GESTURE:
       if (touchstart_expected_soon) {
-        block_expensive_tasks = true;
+        block_expensive_loading_tasks = true;
+        block_expensive_timer_tasks = true;
       } else {
         // What we really want to do is priorize loading tasks, but that doesn't
         // seem to be safe. Instead we do that by proxy by deprioritizing
         // compositor tasks. This should be safe since we've already gone to the
         // pain of fixing ordering issues with them.
         new_policy.compositor_queue_priority = TaskQueue::BEST_EFFORT_PRIORITY;
       }
       break;
 
     case UseCase::MAIN_THREAD_GESTURE:
+      // In main thread gestures we don't have perfect knowledge about which
+      // things we should be prioritizing. The following is best guess
+      // heuristic which lets us produce frames quickly but does not prevent
+      // loading of additional content.
       new_policy.compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
-      block_expensive_tasks = true;
+      block_expensive_loading_tasks = false;
+      block_expensive_timer_tasks = true;
       break;
 
     case UseCase::TOUCHSTART:
       new_policy.compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
       new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
       new_policy.timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
-      block_expensive_tasks = true;  // NOTE this is a nop due to the above.
+      // NOTE these are nops due to the above.
+      block_expensive_loading_tasks = true;
+      block_expensive_timer_tasks = true;
       break;
 
     case UseCase::NONE:
-      if (touchstart_expected_soon)
-        block_expensive_tasks = true;
+      if (touchstart_expected_soon) {
+        block_expensive_loading_tasks = true;
+        block_expensive_timer_tasks = true;
+      }
       break;
 
     case UseCase::LOADING:
       new_policy.loading_queue_priority = TaskQueue::HIGH_PRIORITY;
       new_policy.default_queue_priority = TaskQueue::HIGH_PRIORITY;
       break;
 
     default:
       NOTREACHED();
   }
 
   // Don't block expensive tasks unless we have actually seen something.
-  if (!MainThreadOnly().have_seen_a_begin_main_frame)
-    block_expensive_tasks = false;
+  if (!MainThreadOnly().have_seen_a_begin_main_frame) {
+    block_expensive_loading_tasks = false;
+    block_expensive_timer_tasks = false;
+  }
 
   // Don't block expensive tasks if we are expecting a navigation.
-  if (MainThreadOnly().navigation_task_expected_count > 0)
-    block_expensive_tasks = false;
+  if (MainThreadOnly().navigation_task_expected_count > 0) {
+    block_expensive_loading_tasks = false;
+    block_expensive_timer_tasks = false;
+  }
 
-  if (block_expensive_tasks && loading_tasks_seem_expensive)
+  if (block_expensive_loading_tasks && loading_tasks_seem_expensive)
     new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
 
-  if ((block_expensive_tasks && timer_tasks_seem_expensive) ||
+  if ((block_expensive_timer_tasks && timer_tasks_seem_expensive) ||
       MainThreadOnly().timer_queue_suspend_count != 0 ||
       MainThreadOnly().timer_queue_suspended_when_backgrounded) {
     new_policy.timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
   }
 
   // Tracing is done before the early out check, because it's quite possible we
   // will otherwise miss this information in traces.
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
@@ skipping 275 matching lines @@
   any_thread_lock_.AssertAcquired();
   MainThreadOnly().loading_task_cost_estimator.Clear();
   MainThreadOnly().timer_task_cost_estimator.Clear();
   MainThreadOnly().idle_time_estimator.Clear();
   AnyThread().user_model.Reset(helper_.Now());
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 }  // namespace scheduler