[scheduler] Bunch of improvements for blink scheduler tracing

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 1303 matching lines @@
 
   if (optional_now.is_null())
     optional_now = helper_.scheduler_tqm_delegate()->NowTicks();
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   state->SetBoolean(
       "has_visible_render_widget_with_touch_handler",
       MainThreadOnly().has_visible_render_widget_with_touch_handler);
   state->SetString("current_use_case",
                    UseCaseToString(MainThreadOnly().current_use_case));
-  state->SetString("rail_mode",
-                   RAILModeToString(MainThreadOnly().current_policy.rail_mode));
   state->SetBoolean("loading_tasks_seem_expensive",
                     MainThreadOnly().loading_tasks_seem_expensive);
   state->SetBoolean("timer_tasks_seem_expensive",
                     MainThreadOnly().timer_tasks_seem_expensive);
   state->SetBoolean("begin_frame_not_expected_soon",
                     MainThreadOnly().begin_frame_not_expected_soon);
   state->SetBoolean("touchstart_expected_soon",
                     MainThreadOnly().touchstart_expected_soon);
   state->SetString("idle_period_state",
                    IdleHelper::IdlePeriodStateToString(
@@ skipping 38 matching lines @@
   state->SetDouble("expected_loading_task_duration",
                    MainThreadOnly()
                        .loading_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   state->SetDouble("expected_timer_task_duration",
                    MainThreadOnly()
                        .timer_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   state->SetBoolean("is_audio_playing", MainThreadOnly().is_audio_playing);
 
+  state->BeginDictionary("policy");
+  MainThreadOnly().current_policy.AsValueInto(state.get());
+  state->EndDictionary();
+
   // TODO(skyostil): Can we somehow trace how accurate these estimates were?
   state->SetDouble(
       "longest_jank_free_task_duration",
       MainThreadOnly().longest_jank_free_task_duration.InMillisecondsF());
   state->SetDouble(
       "compositor_frame_interval",
       MainThreadOnly().compositor_frame_interval.InMillisecondsF());
   state->SetDouble(
       "estimated_next_frame_begin",
       (MainThreadOnly().estimated_next_frame_begin - base::TimeTicks())
           .InMillisecondsF());
   state->SetBoolean("in_idle_period", AnyThread().in_idle_period);
 
   state->SetString(

[Sami, 2016/11/22 18:03:28]

Could you move this to the policy too?

[altimin, 2016/11/22 19:01:24]

I don't really like this idea. Currently "policy" dictionary precisely matches
RendererSchedulerImpl::Policy. Given that we compare it and do early opt-out
when it is unchanged, I'd like to leave it this way.

[Sami, 2016/11/22 19:10:27]

Ah, right. I wonder if we could come up with a better name to make it clear that
this defines the policy but actually isn't the policy? I don't have good ideas
right now, so let's just leave it as it is.

       "expensive_task_policy",
       ExpensiveTaskPolicyToString(MainThreadOnly().expensive_task_policy));
 
   AnyThread().user_model.AsValueInto(state.get());
   render_widget_scheduler_signals_.AsValueInto(state.get());
 
   state->BeginDictionary("task_queue_throttler");
   task_queue_throttler_->AsValueInto(state.get(), optional_now);
   state->EndDictionary();
 
   return std::move(state);
 }
 
+void RendererSchedulerImpl::TaskQueuePolicy::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  state->SetBoolean("is_enabled", is_enabled);
+  state->SetString("priority", TaskQueue::PriorityToString(priority));
+  state->SetString("time_domain_type",
+                   TimeDomainTypeToString(time_domain_type));
+}
+
+void RendererSchedulerImpl::Policy::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  state->BeginDictionary("compositor_queue_policy");
+  compositor_queue_policy.AsValueInto(state);
+  state->EndDictionary();
+
+  state->BeginDictionary("loading_queue_policy");
+  loading_queue_policy.AsValueInto(state);
+  state->EndDictionary();
+
+  state->BeginDictionary("timer_queue_policy");
+  timer_queue_policy.AsValueInto(state);
+  state->EndDictionary();
+
+  state->BeginDictionary("default_queue_policy");
+  default_queue_policy.AsValueInto(state);
+  state->EndDictionary();
+
+  state->SetString("rail_mode", RAILModeToString(rail_mode));
+  state->SetBoolean("should_disable_throttling", should_disable_throttling);
+}
+
 void RendererSchedulerImpl::OnIdlePeriodStarted() {
   base::AutoLock lock(any_thread_lock_);
   AnyThread().in_idle_period = true;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
   base::AutoLock lock(any_thread_lock_);
   AnyThread().last_idle_period_end_time =
       helper_.scheduler_tqm_delegate()->NowTicks();
@@ skipping 281 matching lines @@
     case v8::PERFORMANCE_IDLE:
       return "idle";
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
+// static
+const char* RendererSchedulerImpl::TimeDomainTypeToString(
+    TimeDomainType domain_type) {
+  switch (domain_type) {
+    case TimeDomainType::REAL:
+      return "real";
+    case TimeDomainType::THROTTLED:
+      return "throttled";
+    case TimeDomainType::VIRTUAL:
+      return "virtual";
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
 }  // namespace scheduler
 }  // namespace blink