[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"
@@ skipping 18 matching lines @@
 
 }  // namespace
 
 EtwSystemEventConsumer::EtwSystemEventConsumer()
     : thread_("EtwConsumerThread") {
 }
 
 EtwSystemEventConsumer::~EtwSystemEventConsumer() {
 }
 
-bool EtwSystemEventConsumer::StartSystemTracing() {
+std::string EtwSystemEventConsumer::GetTracingAgentName() {
+  return kETWTracingAgentName;
+}
 
+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 =
+  StopAgentTracingCallback 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));
 }
 
 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);
 }
 
+bool EtwSystemEventConsumer::SupportsExplicitClockSync() {
+  return false;
+}
+
+void EtwSystemEventConsumer::RecordClockSyncMarker(
+    scoped_ptr<base::DictionaryValue> marker) {
+  DCHECK(SupportsExplicitClockSync());
+}
+
+void EtwSystemEventConsumer::IssueClockSyncMarker() {
+  DCHECK(SupportsExplicitClockSync());
+}
+
 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();
   p.LogFileMode = EVENT_TRACE_REAL_TIME_MODE;
   p.FlushTimer = kEtwBufferFlushTimeoutInSeconds;
@@ skipping 110 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));
 }
 
 }  // namespace content