Implement frame attribution (FrameBlamer)

components/scheduler/base/task_queue_impl.cc

 // Copyright 2015 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/base/task_queue_impl.h"
 
+#include "base/debug/blame_context.h"
 #include "components/scheduler/base/task_queue_manager.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/base/time_domain.h"
 #include "components/scheduler/base/work_queue.h"
 
 namespace scheduler {
 namespace internal {
 
 TaskQueueImpl::TaskQueueImpl(
     TaskQueueManager* task_queue_manager,
@@ skipping 85 matching lines @@
     TaskQueueManager* task_queue_manager,
     PumpPolicy pump_policy,
     TaskQueueImpl* task_queue,
     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
       pump_policy(pump_policy),
       time_domain(time_domain),
       delayed_work_queue(new WorkQueue(task_queue, "delayed")),
       immediate_work_queue(new WorkQueue(task_queue, "immediate")),
       set_index(0),
-      is_enabled(true) {}
+      is_enabled(true),
+      blame_context(nullptr) {}
 
 TaskQueueImpl::MainThreadOnly::~MainThreadOnly() {}
 
 void TaskQueueImpl::UnregisterTaskQueue() {
   base::AutoLock lock(any_thread_lock_);
   if (main_thread_only().time_domain)
     main_thread_only().time_domain->UnregisterQueue(this);
   if (!any_thread().task_queue_manager)
     return;
   any_thread().time_domain = nullptr;
@@ skipping 474 matching lines @@
 }
 
 void TaskQueueImpl::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   main_thread_only().task_observers.RemoveObserver(task_observer);
 }
 
 void TaskQueueImpl::NotifyWillProcessTask(
     const base::PendingTask& pending_task) {
   DCHECK(should_notify_observers_);
+  if (main_thread_only().blame_context)
+    main_thread_only().blame_context->Enter();
   FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver,
                     main_thread_only().task_observers,
                     WillProcessTask(pending_task));
 }
 
 void TaskQueueImpl::NotifyDidProcessTask(
     const base::PendingTask& pending_task) {
   DCHECK(should_notify_observers_);
   FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver,
                     main_thread_only().task_observers,
                     DidProcessTask(pending_task));
+  if (main_thread_only().blame_context)
+    main_thread_only().blame_context->Leave();
 }
 
 void TaskQueueImpl::SetTimeDomain(TimeDomain* time_domain) {
   base::AutoLock lock(any_thread_lock_);
   DCHECK(time_domain);
   // NOTE this is similar to checking |any_thread().task_queue_manager| but the
   // TaskQueueSelectorTests constructs TaskQueueImpl directly with a null
   // task_queue_manager.  Instead we check |any_thread().time_domain| which is
   // another way of asserting that UnregisterTaskQueue has not been called.
   DCHECK(any_thread().time_domain);
   if (!any_thread().time_domain)
     return;
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (time_domain == main_thread_only().time_domain)
     return;
 
   main_thread_only().time_domain->MigrateQueue(this, time_domain);
   main_thread_only().time_domain = time_domain;
   any_thread().time_domain = time_domain;
 }
 
 TimeDomain* TaskQueueImpl::GetTimeDomain() const {
   if (base::PlatformThread::CurrentId() == thread_id_)
     return main_thread_only().time_domain;
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().time_domain;
 }
 
+void TaskQueueImpl::SetBlameContext(
+    base::debug::BlameContextBase* blame_context) {
+  main_thread_only().blame_context = blame_context;
+}
+
 // static
 void TaskQueueImpl::QueueAsValueInto(const std::queue<Task>& queue,
                                      base::trace_event::TracedValue* state) {
   std::queue<Task> queue_copy(queue);
   while (!queue_copy.empty()) {
     TaskAsValueInto(queue_copy.front(), state);
     queue_copy.pop();
   }
 }
 
@@ skipping 22 matching lines @@
   state->SetBoolean("nestable", task.nestable);
   state->SetBoolean("is_high_res", task.is_high_res);
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler