Assert RendererScheduler thread usage

Use DCHECK to validate the ThreadChecker results in RendererScheduler.

Also add a WARN_UNUSED_RESULT modifier to
ThreadChecker::CalledOnValidThread.

Review URL: https://codereview.chromium.org/904593002

Cr-Commit-Position: refs/heads/master@{#314927}

base/threading/thread_checker.h

@@ -30,7 +30,7 @@ namespace base {
 // right version for your build configuration.
 class ThreadCheckerDoNothing {
  public:
-  bool CalledOnValidThread() const {
+  bool CalledOnValidThread() const WARN_UNUSED_RESULT {
     return true;
   }
 

base/threading/thread_checker_impl.h

@@ -6,6 +6,7 @@
 #define BASE_THREADING_THREAD_CHECKER_IMPL_H_
 
 #include "base/base_export.h"
+#include "base/compiler_specific.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 
@@ -22,7 +23,7 @@ class BASE_EXPORT ThreadCheckerImpl {
   ThreadCheckerImpl();
   ~ThreadCheckerImpl();
 
-  bool CalledOnValidThread() const;
+  bool CalledOnValidThread() const WARN_UNUSED_RESULT;
 
   // Changes the thread that is checked for in CalledOnValidThread.  This may
   // be useful when an object may be created on one thread and then used

content/renderer/scheduler/renderer_scheduler_impl.cc

@@ -64,38 +64,38 @@ RendererSchedulerImpl::~RendererSchedulerImpl() {
 }
 
 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();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   return default_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::CompositorTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   return compositor_task_runner_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
 RendererSchedulerImpl::IdleTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   return idle_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::LoadingTaskRunner() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(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;
 
@@ -106,7 +106,7 @@ void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
 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;
 
@@ -148,7 +148,7 @@ void RendererSchedulerImpl::UpdateForInputEvent() {
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
@@ -157,7 +157,7 @@ bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
 }
 
 bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
@@ -174,17 +174,17 @@ bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
 
 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();
   }
@@ -197,7 +197,7 @@ void RendererSchedulerImpl::PostUpdatePolicyOnControlRunner(
 }
 
 void RendererSchedulerImpl::UpdatePolicy() {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
@@ -254,7 +254,7 @@ void RendererSchedulerImpl::UpdatePolicy() {
 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);
@@ -263,14 +263,14 @@ void RendererSchedulerImpl::StartIdlePeriod() {
 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);
 }
@@ -293,7 +293,6 @@ void RendererSchedulerImpl::PollableNeedsUpdateFlag::SetLocked(bool value) {
 }
 
 bool RendererSchedulerImpl::PollableNeedsUpdateFlag::IsSet() const {
-  thread_checker_.CalledOnValidThread();
   return base::subtle::Acquire_Load(&flag_) != 0;
 }
 
@@ -331,7 +330,7 @@ const char* RendererSchedulerImpl::PolicyToString(Policy policy) {
 
 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())

content/renderer/scheduler/renderer_scheduler_impl.h

@@ -85,7 +85,6 @@ class CONTENT_EXPORT RendererSchedulerImpl : public RendererScheduler {
    private:
     base::subtle::Atomic32 flag_;
     base::Lock* write_lock_;  // Not owned.
-    base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(PollableNeedsUpdateFlag);
   };

content/renderer/scheduler/renderer_task_queue_selector.cc

@@ -18,7 +18,7 @@ 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;
@@ -33,7 +33,7 @@ void RendererTaskQueueSelector::RegisterWorkQueues(
 
 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);
@@ -46,7 +46,7 @@ void RendererTaskQueueSelector::EnableQueue(size_t queue_index,
 }
 
 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;
@@ -93,7 +93,7 @@ bool RendererTaskQueueSelector::ChooseOldestWithPriority(
 
 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)) {
@@ -154,7 +154,7 @@ const char* RendererTaskQueueSelector::PriorityToString(
 
 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)) {

content/renderer/scheduler/task_queue_manager.cc

@@ -317,13 +317,13 @@ bool TaskQueueManager::IsQueueEmpty(size_t queue_index) const {
 }
 
 void TaskQueueManager::SetAutoPump(size_t queue_index, bool auto_pump) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   internal::TaskQueue* queue = Queue(queue_index);
   queue->SetAutoPump(auto_pump);
 }
 
 void TaskQueueManager::PumpQueue(size_t queue_index) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   internal::TaskQueue* queue = Queue(queue_index);
   queue->PumpQueue();
 }
@@ -333,7 +333,7 @@ bool TaskQueueManager::UpdateWorkQueues(
   // TODO(skyostil): This is not efficient when the number of queues grows very
   // large due to the number of locks taken. Consider optimizing when we get
   // there.
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   bool has_work = false;
   for (auto& queue : queues_) {
     has_work |= queue->UpdateWorkQueue(next_pending_delayed_task);
@@ -367,7 +367,7 @@ void TaskQueueManager::DoWork(bool posted_from_main_thread) {
     pending_dowork_count_--;
     DCHECK_GE(pending_dowork_count_, 0);
   }
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
 
   base::TimeTicks next_pending_delayed_task(
       base::TimeTicks::FromInternalValue(kMaxTimeTicks));
@@ -404,7 +404,7 @@ void TaskQueueManager::DidQueueTask(base::PendingTask* pending_task) {
 }
 
 void TaskQueueManager::ProcessTaskFromWorkQueue(size_t queue_index) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   internal::TaskQueue* queue = Queue(queue_index);
   base::PendingTask pending_task = queue->TakeTaskFromWorkQueue();
   if (!pending_task.nestable) {
@@ -431,20 +431,20 @@ bool TaskQueueManager::PostDelayedTask(
 }
 
 void TaskQueueManager::SetQueueName(size_t queue_index, const char* name) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   internal::TaskQueue* queue = Queue(queue_index);
   queue->set_name(name);
 }
 
 void TaskQueueManager::SetWorkBatchSize(int work_batch_size) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_GE(work_batch_size, 1);
   work_batch_size_ = work_batch_size;
 }
 
 void TaskQueueManager::SetTimeSourceForTesting(
     scoped_refptr<cc::TestNowSource> time_source) {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   time_source_ = time_source;
 }
 
@@ -455,7 +455,7 @@ base::TimeTicks TaskQueueManager::Now() const {
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 TaskQueueManager::AsValueWithSelectorResult(bool should_run,
                                             size_t selected_queue) const {
-  main_thread_checker_.CalledOnValidThread();
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<base::debug::TracedValue> state =
       new base::debug::TracedValue();
   state->BeginArray("queues");

content/renderer/scheduler/web_scheduler_impl.cc

@@ -5,6 +5,7 @@
 #include "content/renderer/scheduler/web_scheduler_impl.h"
 
 #include "base/bind.h"
+#include "base/single_thread_task_runner.h"
 #include "content/renderer/scheduler/renderer_scheduler.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
@@ -12,7 +13,8 @@ namespace content {
 
 WebSchedulerImpl::WebSchedulerImpl(RendererScheduler* renderer_scheduler)
     : renderer_scheduler_(renderer_scheduler),
-      idle_task_runner_(renderer_scheduler_->IdleTaskRunner()) {
+      idle_task_runner_(renderer_scheduler_->IdleTaskRunner()),
+      loading_task_runner_(renderer_scheduler_->LoadingTaskRunner()) {
 }
 
 WebSchedulerImpl::~WebSchedulerImpl() {
@@ -34,6 +36,7 @@ void WebSchedulerImpl::runTask(scoped_ptr<blink::WebThread::Task> task) {
 
 void WebSchedulerImpl::postIdleTask(const blink::WebTraceLocation& web_location,
                                     blink::WebScheduler::IdleTask* task) {
+  DCHECK(idle_task_runner_);
   scoped_ptr<blink::WebScheduler::IdleTask> scoped_task(task);
   tracked_objects::Location location(web_location.functionName(),
                                      web_location.fileName(), -1, nullptr);
@@ -44,15 +47,18 @@ void WebSchedulerImpl::postIdleTask(const blink::WebTraceLocation& web_location,
 
 void WebSchedulerImpl::postLoadingTask(
     const blink::WebTraceLocation& web_location, blink::WebThread::Task* task) {
+  DCHECK(loading_task_runner_);
   scoped_ptr<blink::WebThread::Task> scoped_task(task);
   tracked_objects::Location location(web_location.functionName(),
                                      web_location.fileName(), -1, nullptr);
-  renderer_scheduler_->LoadingTaskRunner()->PostTask(
+  loading_task_runner_->PostTask(
       location,
       base::Bind(&WebSchedulerImpl::runTask, base::Passed(&scoped_task)));
 }
 
 void WebSchedulerImpl::shutdown() {
+  idle_task_runner_ = nullptr;
+  loading_task_runner_ = nullptr;
   return renderer_scheduler_->Shutdown();
 }
 

content/renderer/scheduler/web_scheduler_impl.h

@@ -12,6 +12,10 @@
 #include "third_party/WebKit/public/platform/WebScheduler.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace content {
 
 class RendererScheduler;
@@ -36,6 +40,7 @@ class CONTENT_EXPORT WebSchedulerImpl : public blink::WebScheduler {
 
   RendererScheduler* renderer_scheduler_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
 };
 
 }  // namespace content

media/video/capture/mac/video_capture_device_avfoundation_mac.mm

@@ -279,7 +279,7 @@ media::VideoPixelFormat FourCCToChromiumPixelFormat(FourCharCode code) {
   // AVFoundation calls from a number of threads, depending on, at least, if
   // Chrome is on foreground or background. Sample the actual thread here.
   callback_thread_checker_.DetachFromThread();
-  callback_thread_checker_.CalledOnValidThread();
+  CHECK(callback_thread_checker_.CalledOnValidThread());
 
   const CoreMediaGlue::CMFormatDescriptionRef formatDescription =
       CoreMediaGlue::CMSampleBufferGetFormatDescription(sampleBuffer);