Assert RendererScheduler thread usage

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 46 matching lines @@
       this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 }
 
 void RendererSchedulerImpl::Shutdown() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   task_queue_manager_.reset();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::DefaultTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();

[rmcilroy, 2015/02/05 18:50:00]

I'm not sure we can remove these checks - this is the comment from sievers@ on
the original review which caused me to add these in the first place:

  You can't access |this| from another thread because |this| might 
  get deleted while you are calling into it which will crash.
  Everybody needs to acquire a reference to the task runners from
  the main thread and then hold on to it.


 

   return default_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::CompositorTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();
   return compositor_task_runner_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
 RendererSchedulerImpl::IdleTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();
   return idle_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::LoadingTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();
   return loading_task_runner_;
 }
 
 void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::WillBeginFrame", "args", args.AsValue());
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
   EndIdlePeriod();
   estimated_next_frame_begin_ = args.frame_time + args.interval;
 }
 
 void RendererSchedulerImpl::DidCommitFrameToCompositor() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
   base::TimeTicks now(Now());
   if (now < estimated_next_frame_begin_) {
     StartIdlePeriod();
     control_task_runner_->PostDelayedTask(FROM_HERE,
                                           end_idle_period_closure_.callback(),
                                           estimated_next_frame_begin_ - now);
   }
@@ skipping 21 matching lines @@
   base::AutoLock lock(incoming_signals_lock_);
   if (last_input_time_.is_null()) {
     // Update scheduler policy if should start a new compositor policy mode.
     policy_may_need_update_.SetLocked(true);
     PostUpdatePolicyOnControlRunner(base::TimeDelta());
   }
   last_input_time_ = Now();
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
   MaybeUpdatePolicy();
   return SchedulerPolicy() == COMPOSITOR_PRIORITY_POLICY;
 }
 
 bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
   MaybeUpdatePolicy();
   // We only yield if we are in the compositor priority and there is compositor
   // work outstanding. Note: even though the control queue is higher priority
   // we don't yield for it since these tasks are not user-provided work and they
   // are only intended to run before the next task, not interrupt the tasks.
   // Note: This function could conceivably be implemented in terms of
   // |IsHighPriorityWorkAnticipated|, but for clarity is not.
   return SchedulerPolicy() == COMPOSITOR_PRIORITY_POLICY &&
          !task_queue_manager_->IsQueueEmpty(COMPOSITOR_TASK_QUEUE);
 }
 
 void RendererSchedulerImpl::CurrentIdleTaskDeadlineCallback(
     base::TimeTicks* deadline_out) const {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   *deadline_out = estimated_next_frame_begin_;
 }
 
 RendererSchedulerImpl::Policy RendererSchedulerImpl::SchedulerPolicy() const {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   return current_policy_;
 }
 
 void RendererSchedulerImpl::MaybeUpdatePolicy() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (policy_may_need_update_.IsSet()) {
     UpdatePolicy();
   }
 }
 
 void RendererSchedulerImpl::PostUpdatePolicyOnControlRunner(
     base::TimeDelta delay) {
   control_task_runner_->PostDelayedTask(
       FROM_HERE, update_policy_closure_, delay);
 }
 
 void RendererSchedulerImpl::UpdatePolicy() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
   base::AutoLock lock(incoming_signals_lock_);
   base::TimeTicks now;
   policy_may_need_update_.SetLocked(false);
 
   Policy new_policy = NORMAL_PRIORITY_POLICY;
   if (!last_input_time_.is_null()) {
     base::TimeDelta compositor_priority_duration =
@@ skipping 36 matching lines @@
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.policy", current_policy_);
 }
 
 void RendererSchedulerImpl::StartIdlePeriod() {
   TRACE_EVENT_ASYNC_BEGIN0("renderer.scheduler",
                            "RendererSchedulerIdlePeriod", this);
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   renderer_task_queue_selector_->EnableQueue(
       IDLE_TASK_QUEUE, RendererTaskQueueSelector::BEST_EFFORT_PRIORITY);
   task_queue_manager_->PumpQueue(IDLE_TASK_QUEUE);
 }
 
 void RendererSchedulerImpl::EndIdlePeriod() {
   TRACE_EVENT_ASYNC_END0("renderer.scheduler",
                          "RendererSchedulerIdlePeriod", this);
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   end_idle_period_closure_.Cancel();
   renderer_task_queue_selector_->DisableQueue(IDLE_TASK_QUEUE);
 }
 
 void RendererSchedulerImpl::SetTimeSourceForTesting(
     scoped_refptr<cc::TestNowSource> time_source) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   time_source_ = time_source;
   task_queue_manager_->SetTimeSourceForTesting(time_source);
 }
 
 base::TimeTicks RendererSchedulerImpl::Now() const {
   return UNLIKELY(time_source_) ? time_source_->Now() : base::TimeTicks::Now();
 }
 
 RendererSchedulerImpl::PollableNeedsUpdateFlag::PollableNeedsUpdateFlag(
     base::Lock* write_lock_)
     : flag_(false), write_lock_(write_lock_) {
 }
 
 RendererSchedulerImpl::PollableNeedsUpdateFlag::~PollableNeedsUpdateFlag() {
 }
 
 void RendererSchedulerImpl::PollableNeedsUpdateFlag::SetLocked(bool value) {
   write_lock_->AssertAcquired();
   base::subtle::Release_Store(&flag_, value);
 }
 
 bool RendererSchedulerImpl::PollableNeedsUpdateFlag::IsSet() const {
-  thread_checker_.CalledOnValidThread();
   return base::subtle::Acquire_Load(&flag_) != 0;
 }
 
 // static
 const char* RendererSchedulerImpl::TaskQueueIdToString(QueueId queue_id) {
   switch (queue_id) {
     case DEFAULT_TASK_QUEUE:
       return "default_tq";
     case COMPOSITOR_TASK_QUEUE:
       return "compositor_tq";
@@ skipping 17 matching lines @@
     case COMPOSITOR_PRIORITY_POLICY:
       return "compositor";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   incoming_signals_lock_.AssertAcquired();
 
   if (optional_now.is_null())
     optional_now = Now();
   scoped_refptr<base::debug::TracedValue> state =
       new base::debug::TracedValue();
 
   state->SetString("current_policy", PolicyToString(current_policy_));
   state->SetDouble("now", (optional_now - base::TimeTicks()).InMillisecondsF());
   state->SetDouble("last_input_time",
                    (last_input_time_ - base::TimeTicks()).InMillisecondsF());
   state->SetDouble(
       "estimated_next_frame_begin",
       (estimated_next_frame_begin_ - base::TimeTicks()).InMillisecondsF());
 
   return state;
 }
 
 }  // namespace content