Implement frame attribution (FrameBlamer)

components/scheduler/base/task_queue_manager_unittest.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 "components/scheduler/base/task_queue_manager.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/location.h"
+#include "base/memory/ref_counted_memory.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "base/test/trace_event_analyzer.h"
 #include "base/threading/thread.h"
+#include "base/trace_event/blame_context.h"
+#include "base/trace_event/trace_buffer.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "components/scheduler/base/real_time_domain.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h"
 #include "components/scheduler/base/task_queue_selector.h"
 #include "components/scheduler/base/test_always_fail_time_source.h"
 #include "components/scheduler/base/test_time_source.h"
 #include "components/scheduler/base/virtual_time_domain.h"
 #include "components/scheduler/base/work_queue.h"
 #include "components/scheduler/base/work_queue_sets.h"
@@ skipping 1810 matching lines @@
   queue0->PostTask(
       FROM_HERE, base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask,
                             message_loop_.get(), manager_.get(), &task_sources,
                             &tasks_to_post_from_nested_loop));
 
   message_loop_->RunUntilIdle();
   EXPECT_THAT(task_sources, ElementsAre(queue0, queue1, queue2, queue0));
   EXPECT_EQ(nullptr, manager_->currently_executing_task_queue());
 }
 
+void OnTraceDataCollected(base::Closure quit_closure,
+                          base::trace_event::TraceResultBuffer* buffer,
+                          const scoped_refptr<base::RefCountedString>& json,
+                          bool has_more_events) {
+  buffer->AddFragment(json->data());
+  if (!has_more_events)
+    quit_closure.Run();
+}
+
+class TaskQueueManagerTestWithTracing : public TaskQueueManagerTest {
+ public:
+  void StartTracing();
+  void StopTracing();
+  scoped_ptr<trace_analyzer::TraceAnalyzer> CreateTraceAnalyzer();
+};
+
+void TaskQueueManagerTestWithTracing::StartTracing() {
+  base::trace_event::TraceLog::GetInstance()->SetEnabled(
+      base::trace_event::TraceConfig("*"),
+      base::trace_event::TraceLog::RECORDING_MODE);
+}
+
+void TaskQueueManagerTestWithTracing::StopTracing() {
+  base::trace_event::TraceLog::GetInstance()->SetDisabled();
+}
+
+scoped_ptr<trace_analyzer::TraceAnalyzer>
+TaskQueueManagerTestWithTracing::CreateTraceAnalyzer() {
+  base::trace_event::TraceResultBuffer buffer;
+  base::trace_event::TraceResultBuffer::SimpleOutput trace_output;
+  buffer.SetOutputCallback(trace_output.GetCallback());
+  base::RunLoop run_loop;
+  buffer.Start();
+  base::trace_event::TraceLog::GetInstance()->Flush(
+      Bind(&OnTraceDataCollected, run_loop.QuitClosure(),
+           base::Unretained(&buffer)));
+  run_loop.Run();
+  buffer.Finish();
+
+  return make_scoped_ptr(
+      trace_analyzer::TraceAnalyzer::Create(trace_output.json_output));
+}
+
+TEST_F(TaskQueueManagerTestWithTracing, BlameContextAttribution) {
+  using trace_analyzer::Query;
+
+  Initialize(1u);
+  TaskQueue* queue = runners_[0].get();
+
+  StartTracing();
+  {
+    base::trace_event::BlameContext blame_context("cat", "name", "type",
+                                                  "scope", 0, nullptr);
+    blame_context.Initialize();
+    queue->SetBlameContext(&blame_context);
+    queue->PostTask(FROM_HERE, base::Bind(&NopTask));
+    test_task_runner_->RunUntilIdle();
+  }
+  StopTracing();
+  scoped_ptr<trace_analyzer::TraceAnalyzer> analyzer = CreateTraceAnalyzer();
+
+  trace_analyzer::TraceEventVector events;
+  Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) ||
+            Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT);
+  analyzer->FindEvents(q, &events);
+
+  EXPECT_EQ(2u, events.size());
+}
+
 }  // namespace scheduler