[content]: Add CanExceedIdleDeadlineIfRequired function to RendererScheduler.

content/renderer/scheduler/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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 486 matching lines @@
   }
   TRACE_EVENT_ASYNC_END0("renderer.scheduler",
                          "RendererSchedulerIdlePeriod", this);
   DCHECK(main_thread_checker_.CalledOnValidThread());
   end_idle_period_closure_.Cancel();
   initiate_next_long_idle_period_closure_.Cancel();
   after_wakeup_initiate_next_long_idle_period_closure_.Cancel();
   renderer_task_queue_selector_->DisableQueue(IDLE_TASK_QUEUE);
 }
 
+bool RendererSchedulerImpl::IsMaximumIdleDeadline(
+    base::TimeTicks deadline) const {
+  base::TimeDelta deadline_duration = deadline - Now();
+  base::TimeDelta max_idle_duration =
+      base::TimeDelta::FromMilliseconds(kMaximumIdlePeriodMillis);
+  // Allow one millisecond slop.

[Sami, 2015/03/03 16:21:32]

I was thinking about the need to have this back-and-forth between the scheduler
and the client to figure out whether this was the maximum deadline or not and
that the answer depends on when you call this function even if the deadline
itself remains the same.

Should we instead frame this as IsAllowedToExceedDeadline() or something to that
effect to make it less about the deadline itself but more about the underlying
system state? One reason for doing this is that perhaps we want to start giving
out super long deadlines for backgrounded tabs or something, in which case this
function needs to start lying :)

[rmcilroy, 2015/03/05 11:20:36]

I've reworked this to expose a CanExceedIdleDeadlineIfRequired, which I think is
a much better solution - thanks for the idea.  PTAL.

+  return max_idle_duration - deadline_duration <=
+         base::TimeDelta::FromMilliseconds(1);

[picksi, 2015/03/04 10:56:14]

Nit: You could remove the need for the "one millisecond slop" comment if you had
a named const for the '1'.

[rmcilroy, 2015/03/05 11:20:36]

Removed all this code :).

+}
+
 void RendererSchedulerImpl::SetTimeSourceForTesting(
     scoped_refptr<cc::TestNowSource> time_source) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   time_source_ = time_source;
   task_queue_manager_->SetTimeSourceForTesting(time_source);
 }
 
 void RendererSchedulerImpl::SetWorkBatchSizeForTesting(size_t work_batch_size) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   task_queue_manager_->SetWorkBatchSize(work_batch_size);
@@ skipping 143 matching lines @@
 }
 
 void RendererSchedulerImpl::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace content