[Tracing Clock Sync] Add TracingAgent interface in Chrome

content/browser/tracing/etw_system_event_consumer_win.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/browser/tracing/etw_system_event_consumer_win.h"
 
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 
+const char kETWTracingAgentName[] = "etw";
+const char kETWTraceLabel[] = "systemTraceEvents";
+
 const int kEtwBufferSizeInKBytes = 16;
 const int kEtwBufferFlushTimeoutInSeconds = 1;
 
 std::string GuidToString(const GUID& guid) {
   return base::StringPrintf("%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
       guid.Data1, guid.Data2, guid.Data3,
       guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
       guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
 }
 
 }  // namespace
 
 EtwSystemEventConsumer::EtwSystemEventConsumer()
     : thread_("EtwConsumerThread") {
 }
 
 EtwSystemEventConsumer::~EtwSystemEventConsumer() {
 }
 
-bool EtwSystemEventConsumer::StartSystemTracing() {
+std::string EtwSystemEventConsumer::GetTracingAgentName() {
+  return kETWTracingAgentName;
+}
 
+std::string EtwSystemEventConsumer::GetTraceEventLabel() {
+  return kETWTraceLabel;
+}
+
+bool EtwSystemEventConsumer::StartAgentTracing(
+    const base::trace_event::TraceConfig& trace_config) {
   // Activate kernel tracing.
   if (!StartKernelSessionTracing())
     return false;
 
   // Start the consumer thread and start consuming events.
   thread_.Start();
   thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&EtwSystemEventConsumer::TraceAndConsumeOnThread,
                  base::Unretained(this)));
 
   return true;
 }
 
-void EtwSystemEventConsumer::StopSystemTracing(const OutputCallback& callback) {
+void EtwSystemEventConsumer::StopAgentTracing(
+    const StopAgentTracingCallback& callback) {
   // Deactivate kernel tracing.
   if (!StopKernelSessionTracing()) {
     LOG(FATAL) << "Could not stop system tracing.";
   }
 
   // Stop consuming and flush events.
-  OutputCallback on_stop_system_tracing_done_callback =
-      base::Bind(&EtwSystemEventConsumer::OnStopSystemTracingDone,
-                 base::Unretained(this),
-                 callback);
   thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&EtwSystemEventConsumer::FlushOnThread,
-                 base::Unretained(this), on_stop_system_tracing_done_callback));
+                 base::Unretained(this),
+                 callback));
 }
 
 void EtwSystemEventConsumer::OnStopSystemTracingDone(
-    const OutputCallback& callback,
+    const StopAgentTracingCallback& callback,
     const scoped_refptr<base::RefCountedString>& result) {
 
   // Stop the consumer thread.
   thread_.Stop();
 
   // Pass the serialized events.
-  callback.Run(result);
+  callback.Run(GetTracingAgentName(), GetTraceEventLabel(), result);
 }
 
 bool EtwSystemEventConsumer::StartKernelSessionTracing() {
   // Enabled flags (tracing facilities).
   uint32 enabled_flags = EVENT_TRACE_FLAG_IMAGE_LOAD |
                          EVENT_TRACE_FLAG_PROCESS |
                          EVENT_TRACE_FLAG_THREAD |
                          EVENT_TRACE_FLAG_CSWITCH;
 
   EVENT_TRACE_PROPERTIES& p = *properties_.get();
@@ skipping 112 matching lines @@
   // Output a clock sync event.
   AddSyncEventToBuffer();
 
   HRESULT hr = OpenRealtimeSession(KERNEL_LOGGER_NAME);
   if (FAILED(hr))
     return;
   Consume();
   Close();
 }
 
-void EtwSystemEventConsumer::FlushOnThread(const OutputCallback& callback) {
+void EtwSystemEventConsumer::FlushOnThread(
+    const StopAgentTracingCallback& callback) {
   // Add the header information to the stream.
   scoped_ptr<base::DictionaryValue> header(new base::DictionaryValue());
   header->Set("name", new base::StringValue("ETW"));
 
   // Release and pass the events buffer.
   header->Set("content", events_.release());
 
   // Serialize the results as a JSon string.
   std::string output;
   JSONStringValueSerializer serializer(&output);
   serializer.Serialize(*header.get());
 
   // Pass the result to the UI Thread.
   scoped_refptr<base::RefCountedString> result =
       base::RefCountedString::TakeString(&output);
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(callback, result));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&EtwSystemEventConsumer::OnStopSystemTracingDone,
+                 base::Unretained(this),
+                 callback,
+                 result));
 }
 
 }  // namespace content