Pipe impl_latency_takes_priority_ to the RenderScheduler.

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 23 matching lines @@
       timer_task_runner_(helper_.TaskRunnerForQueue(TIMER_TASK_QUEUE)),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       current_policy_(Policy::NORMAL),
       renderer_hidden_(false),
       was_shutdown_(false),
       pending_main_thread_input_event_count_(0),
       awaiting_touch_start_response_(false),
+      begin_main_frame_on_critical_path_(false),
       last_input_type_(blink::WebInputEvent::Undefined),
       policy_may_need_update_(&incoming_signals_lock_),
       timer_queue_suspend_count_(0),
       in_idle_period_(false),
       weak_factory_(this) {
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
@@ skipping 65 matching lines @@
 
 void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::WillBeginFrame", "args", args.AsValue());
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   EndIdlePeriod();
   estimated_next_frame_begin_ = args.frame_time + args.interval;
+  begin_main_frame_on_critical_path_ = args.on_critical_path;
 }
 
 void RendererSchedulerImpl::DidCommitFrameToCompositor() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   base::TimeTicks now(helper_.Now());
@@ skipping 446 matching lines @@
                        idle_helper_.SchedulerIdlePeriodState()));
   state->SetBoolean("renderer_hidden", renderer_hidden_);
   state->SetDouble("now", (optional_now - base::TimeTicks()).InMillisecondsF());
   state->SetDouble(
       "last_input_signal_time",
       (last_input_signal_time_ - base::TimeTicks()).InMillisecondsF());
   state->SetInteger("pending_main_thread_input_event_count",
                     pending_main_thread_input_event_count_);
   state->SetBoolean("awaiting_touch_start_response",
                     awaiting_touch_start_response_);
+  state->SetBoolean("begin_main_frame_on_critical_path",
+                    begin_main_frame_on_critical_path_);
   state->SetDouble(
       "estimated_next_frame_begin",
       (estimated_next_frame_begin_ - base::TimeTicks()).InMillisecondsF());
   state->SetBoolean("in_idle_period", in_idle_period_);
 
   return state;
 }
 
 void RendererSchedulerImpl::OnIdlePeriodStarted() {
   in_idle_period_ = true;
   // TODO(alexclarke): Force update the policy
 }
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
   in_idle_period_ = false;
   // TODO(alexclarke): Force update the policy
 }
 
 }  // namespace scheduler