[Tracing Clock Sync] Add TracingAgent interface in Chrome

chromeos/dbus/debug_daemon_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/debug_daemon_client.h"
 
 #include <fcntl.h>
 #include <unistd.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "chromeos/dbus/pipe_reader.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 namespace {
 
-// Used in DebugDaemonClient::EmptySystemStopTracingCallback().
-void EmptyStopSystemTracingCallbackBody(
-  const scoped_refptr<base::RefCountedString>& unused_result) {
-}
+const char kCrOSTracingAgentName[] = "cros";
+const char kCrOSTraceLabel[] = "systemTraceEvents";
+
+// Used in DebugDaemonClient::EmptyStopAgentTracingCallback().
+void EmptyStopAgentTracingCallbackBody(
+    const std::string& agent_name,
+    const std::string& events_label,
+    const scoped_refptr<base::RefCountedString>& unused_result) {}
 
 }  // namespace
 
 namespace chromeos {
 
 // The DebugDaemonClient implementation used in production.
 class DebugDaemonClientImpl : public DebugDaemonClient {
  public:
   DebugDaemonClientImpl() : debugdaemon_proxy_(NULL), weak_ptr_factory_(this) {}
 
@@ skipping 145 matching lines @@
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetUserLogFiles);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetUserLogFiles,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  void StartSystemTracing() override {
+  // base::trace_event::TracingAgent implementation.
+  std::string GetTracingAgentName() override { return kCrOSTracingAgentName; }
+
+  std::string GetTraceEventLabel() override { return kCrOSTraceLabel; }
+
+  bool StartAgentTracing(
+      const base::trace_event::TraceConfig& trace_config) override {
     dbus::MethodCall method_call(
         debugd::kDebugdInterface,
         debugd::kSystraceStart);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("all"); // TODO(sleffler) parameterize category list
 
     DVLOG(1) << "Requesting a systrace start";
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnStartMethod,
                    weak_ptr_factory_.GetWeakPtr()));
+    return true;
   }
 
-  bool RequestStopSystemTracing(
-      scoped_refptr<base::TaskRunner> task_runner,
-      const StopSystemTracingCallback& callback) override {
+  void StopAgentTracing(const StopAgentTracingCallback& callback) override {
+    DCHECK(stop_agent_tracing_task_runner_);
     if (pipe_reader_ != NULL) {
       LOG(ERROR) << "Busy doing StopSystemTracing";
-      return false;
+      return;
     }
 
-    pipe_reader_.reset(new PipeReaderForString(
-        task_runner,
-        base::Bind(&DebugDaemonClientImpl::OnIOComplete,
-                   weak_ptr_factory_.GetWeakPtr())));
+    pipe_reader_.reset(
+        new PipeReaderForString(stop_agent_tracing_task_runner_,
+                                base::Bind(&DebugDaemonClientImpl::OnIOComplete,
+                                           weak_ptr_factory_.GetWeakPtr())));
 
     base::File pipe_write_end = pipe_reader_->StartIO();
     // Create dbus::FileDescriptor on the worker thread; on return we'll
     // issue the D-Bus request to stop tracing and collect results.
     base::PostTaskAndReplyWithResult(
-        task_runner.get(),
-        FROM_HERE,
+        stop_agent_tracing_task_runner_.get(), FROM_HERE,
         base::Bind(
             &DebugDaemonClientImpl::CreateFileDescriptorToStopSystemTracing,
             base::Passed(&pipe_write_end)),
         base::Bind(
             &DebugDaemonClientImpl::OnCreateFileDescriptorRequestStopSystem,
-            weak_ptr_factory_.GetWeakPtr(),
-            callback));
-    return true;
+            weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+  void SetStopAgentTracingTaskRunner(
+      scoped_refptr<base::TaskRunner> task_runner) override {
+    stop_agent_tracing_task_runner_ = task_runner;
   }
 
   void TestICMP(const std::string& ip_address,
                 const TestICMPCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kTestICMP);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(ip_address);
     debugdaemon_proxy_->CallMethod(
         &method_call,
@@ skipping 301 matching lines @@
       // TODO(sleffler) if this fails AppendFileDescriptor will abort
     }
     scoped_ptr<dbus::FileDescriptor> file_descriptor(new dbus::FileDescriptor);
     file_descriptor->PutValue(pipe_write_end.TakePlatformFile());
     file_descriptor->CheckValidity();
     return file_descriptor.Pass();
   }
 
   // Called when a CheckValidity response is received.
   void OnCreateFileDescriptorRequestStopSystem(
-      const StopSystemTracingCallback& callback,
+      const StopAgentTracingCallback& callback,
       scoped_ptr<dbus::FileDescriptor> file_descriptor) {
     DCHECK(file_descriptor);
 
     // Issue the dbus request to stop system tracing
     dbus::MethodCall method_call(
         debugd::kDebugdInterface,
         debugd::kSystraceStop);
     dbus::MessageWriter writer(&method_call);
     writer.AppendFileDescriptor(*file_descriptor);
 
     callback_ = callback;
 
     DVLOG(1) << "Requesting a systrace stop";
     debugdaemon_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&DebugDaemonClientImpl::OnRequestStopSystemTracing,
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnStopAgentTracing,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  // Called when a response for RequestStopSystemTracing() is received.
-  void OnRequestStopSystemTracing(dbus::Response* response) {
+  // Called when a response for StopAgentTracing() is received.
+  void OnStopAgentTracing(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to request systrace stop";
       // If debugd crashes or completes I/O before this message is processed
       // then pipe_reader_ can be NULL, see OnIOComplete().
       if (pipe_reader_.get())
         pipe_reader_->OnDataReady(-1); // terminate data stream
     }
     // NB: requester is signaled when i/o completes
   }
 
   void OnTestICMP(const TestICMPCallback& callback, dbus::Response* response) {
     std::string status;
     if (response && dbus::MessageReader(response).PopString(&status))
       callback.Run(true, status);
     else
       callback.Run(false, "");
   }
 
   // Called when pipe i/o completes; pass data on and delete the instance.
   void OnIOComplete() {
     std::string pipe_data;
     pipe_reader_->GetData(&pipe_data);
-    callback_.Run(base::RefCountedString::TakeString(&pipe_data));
+    callback_.Run(GetTracingAgentName(), GetTraceEventLabel(),
+                  base::RefCountedString::TakeString(&pipe_data));
     pipe_reader_.reset();
   }
 
   dbus::ObjectProxy* debugdaemon_proxy_;
   scoped_ptr<PipeReaderForString> pipe_reader_;
-  StopSystemTracingCallback callback_;
+  StopAgentTracingCallback callback_;
+  scoped_refptr<base::TaskRunner> stop_agent_tracing_task_runner_;
   base::WeakPtrFactory<DebugDaemonClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugDaemonClientImpl);
 };
 
 DebugDaemonClient::DebugDaemonClient() {
 }
 
 DebugDaemonClient::~DebugDaemonClient() {
 }
 
 // static
-DebugDaemonClient::StopSystemTracingCallback
-DebugDaemonClient::EmptyStopSystemTracingCallback() {
-  return base::Bind(&EmptyStopSystemTracingCallbackBody);
+DebugDaemonClient::StopAgentTracingCallback
+DebugDaemonClient::EmptyStopAgentTracingCallback() {
+  return base::Bind(&EmptyStopAgentTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create() {
   return new DebugDaemonClientImpl();
 }
 
 }  // namespace chromeos