[Tracing] Remove base::Thread usage from ETWTracingAgent

post_task.h is now preferred to creating special purposed base::Threads

All this code needs is a SequencedTaskRunner which is allowed to
perform file I/O.

Furthermore, PlatformThread::Join() and hence Thread::Stop() will be
marked as a blocking operation in
https://chromium-review.googlesource.com/c/chromium/src/+/1324370
and this code was preventing that (even though in this case the
Join() was mostly a fast operation as there were no tasks left by the
time it was invoked).

R=chiniforooshan@chromium.org

Bug: 707362
Change-Id: Iec2f823e762cea2d1d1e775117fd95d871baa574
Reviewed-on: https://chromium-review.googlesource.com/c/1338178Reviewed-by: Ehsan Chiniforooshan <chiniforooshan@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#608610}

base/win/event_trace_consumer.h

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "base/threading/scoped_blocking_call.h"
 
 namespace base {
 namespace win {
@@ -120,6 +121,7 @@ HRESULT EtwTraceConsumerBase<ImplClass>::OpenFileSession(
 
 template <class ImplClass> inline
 HRESULT EtwTraceConsumerBase<ImplClass>::Consume() {
+  base::ScopedBlockingCall scoped_blocking_call(base::BlockingType::MAY_BLOCK);
   ULONG err = ::ProcessTrace(&trace_handles_[0],
                              static_cast<ULONG>(trace_handles_.size()),
                              NULL,

content/browser/tracing/etw_tracing_agent_win.cc

@@ -50,7 +50,8 @@ EtwTracingAgent::EtwTracingAgent(service_manager::Connector* connector)
                 tracing::mojom::TraceDataType::OBJECT,
                 false /* supports_explicit_clock_sync */,
                 base::kNullProcessId),
-      thread_("EtwConsumerThread"),
+      tracing_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
       is_tracing_(false) {
   DCHECK(!g_etw_tracing_agent);
   g_etw_tracing_agent = this;
@@ -73,14 +74,12 @@ void EtwTracingAgent::StartTracing(const std::string& config,
   }
   is_tracing_ = true;
 
-  // Start the consumer thread and start consuming events.
-  thread_.Start();
-
   // Tracing agents, e.g. this, live as long as BrowserMainLoop lives and so
   // using base::Unretained here is safe.
-  thread_.task_runner()->PostTask(
-      FROM_HERE, base::BindOnce(&EtwTracingAgent::TraceAndConsumeOnThread,
-                                base::Unretained(this)));
+  tracing_task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&EtwTracingAgent::TraceAndConsumeOnTracingSequence,
+                     base::Unretained(this)));
   std::move(callback).Run(true /* success */);
 }
 
@@ -93,16 +92,14 @@ void EtwTracingAgent::StopAndFlush(tracing::mojom::RecorderPtr recorder) {
   recorder_ = std::move(recorder);
   // Stop consuming and flush events. Tracing agents, e.g. this, live as long as
   // BrowserMainLoop lives and so using base::Unretained here is safe.
-  thread_.task_runner()->PostTask(
-      FROM_HERE,
-      base::BindOnce(&EtwTracingAgent::FlushOnThread, base::Unretained(this)));
+  tracing_task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&EtwTracingAgent::FlushOnTracingSequence,
+                                base::Unretained(this)));
 }
 
 void EtwTracingAgent::OnStopSystemTracingDone(const std::string& output) {
   recorder_->AddChunk(output);
   recorder_.reset();
-  // Stop the consumer thread.
-  thread_.Stop();
   is_tracing_ = false;
 }
 
@@ -217,7 +214,9 @@ void EtwTracingAgent::AppendEventToBuffer(EVENT_TRACE* event) {
   events_->Append(std::move(value));
 }
 
-void EtwTracingAgent::TraceAndConsumeOnThread() {
+void EtwTracingAgent::TraceAndConsumeOnTracingSequence() {
+  DCHECK(tracing_task_runner_->RunsTasksInCurrentSequence());
+
   // Create the events buffer.
   events_.reset(new base::ListValue());
 
@@ -231,7 +230,9 @@ void EtwTracingAgent::TraceAndConsumeOnThread() {
   Close();
 }
 
-void EtwTracingAgent::FlushOnThread() {
+void EtwTracingAgent::FlushOnTracingSequence() {
+  DCHECK(tracing_task_runner_->RunsTasksInCurrentSequence());
+
   // Add the header information to the stream.
   auto header = std::make_unique<base::DictionaryValue>();
   header->SetString("name", "ETW");

content/browser/tracing/etw_tracing_agent_win.h

@@ -11,7 +11,7 @@
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/threading/thread.h"
+#include "base/sequenced_task_runner.h"
 #include "base/values.h"
 #include "base/win/event_trace_consumer.h"
 #include "base/win/event_trace_controller.h"
@@ -61,11 +61,13 @@ class EtwTracingAgent : public base::win::EtwTraceConsumerBase<EtwTracingAgent>,
   bool StopKernelSessionTracing();
 
   void OnStopSystemTracingDone(const std::string& output);
-  void TraceAndConsumeOnThread();
-  void FlushOnThread();
+  void TraceAndConsumeOnTracingSequence();
+  void FlushOnTracingSequence();
+
+  // Task runner used to communicate with the native tracing interface.
+  scoped_refptr<base::SequencedTaskRunner> tracing_task_runner_;
 
   std::unique_ptr<base::ListValue> events_;
-  base::Thread thread_;
   TRACEHANDLE session_handle_;
   base::win::EtwTraceProperties properties_;
   tracing::mojom::RecorderPtr recorder_;