Assert RendererScheduler thread usage

content/renderer/scheduler/renderer_task_queue_selector.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_task_queue_selector.h"
 
 #include "base/logging.h"
 #include "base/pending_task.h"
 #include "base/trace_event/trace_event_argument.h"
 
 namespace content {
 
 RendererTaskQueueSelector::RendererTaskQueueSelector() : starvation_count_(0) {
 }
 
 RendererTaskQueueSelector::~RendererTaskQueueSelector() {
 }
 
 void RendererTaskQueueSelector::RegisterWorkQueues(
     const std::vector<const base::TaskQueue*>& work_queues) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   work_queues_ = work_queues;
   for (QueuePriority priority = FIRST_QUEUE_PRIORITY;
        priority < QUEUE_PRIORITY_COUNT;
        priority = NextPriority(priority)) {
     queue_priorities_[priority].clear();
   }
   // By default, all work queues are set to normal priority.
   for (size_t i = 0; i < work_queues.size(); i++) {
     queue_priorities_[NORMAL_PRIORITY].insert(i);
   }
 }
 
 void RendererTaskQueueSelector::SetQueuePriority(size_t queue_index,
                                                  QueuePriority priority) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   DCHECK_LT(priority, QUEUE_PRIORITY_COUNT);
   DisableQueue(queue_index);
   queue_priorities_[priority].insert(queue_index);
 }
 
 void RendererTaskQueueSelector::EnableQueue(size_t queue_index,
                                             QueuePriority priority) {
   SetQueuePriority(queue_index, priority);
 }
 
 void RendererTaskQueueSelector::DisableQueue(size_t queue_index) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   for (QueuePriority priority = FIRST_QUEUE_PRIORITY;
        priority < QUEUE_PRIORITY_COUNT;
        priority = NextPriority(priority)) {
     queue_priorities_[priority].erase(queue_index);
   }
 }
 
 bool RendererTaskQueueSelector::IsOlder(const base::TaskQueue* queueA,
                                         const base::TaskQueue* queueB) {
@@ skipping 26 matching lines @@
   }
 
   if (found_non_empty_queue) {
     *out_queue_index = chosen_queue;
   }
   return found_non_empty_queue;
 }
 
 bool RendererTaskQueueSelector::SelectWorkQueueToService(
     size_t* out_queue_index) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(work_queues_.size());
   // Always service the control queue if it has any work.
   if (ChooseOldestWithPriority(CONTROL_PRIORITY, out_queue_index)) {
     DidSelectQueueWithPriority(CONTROL_PRIORITY);
     return true;
   }
   // Select from the normal priority queue if we are starving it.
   if (starvation_count_ >= kMaxStarvationTasks &&
       ChooseOldestWithPriority(NORMAL_PRIORITY, out_queue_index)) {
     DidSelectQueueWithPriority(NORMAL_PRIORITY);
@@ skipping 40 matching lines @@
     case BEST_EFFORT_PRIORITY:
       return "best_effort";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 void RendererTaskQueueSelector::AsValueInto(
     base::debug::TracedValue* state) const {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   state->BeginDictionary("priorities");
   for (QueuePriority priority = FIRST_QUEUE_PRIORITY;
        priority < QUEUE_PRIORITY_COUNT; priority = NextPriority(priority)) {
     state->BeginArray(PriorityToString(priority));
     for (size_t queue_index : queue_priorities_[priority])
       state->AppendInteger(queue_index);
     state->EndArray();
   }
   state->EndDictionary();
   state->SetInteger("starvation_count", starvation_count_);
 }
 
 }  // namespace content