tracing: get rid of files in TracingController interface

content/public/browser/tracing_controller.h

 // Copyright 2013 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_TRACING_CONTROLLER_H_
 #define CONTENT_PUBLIC_BROWSER_TRACING_CONTROLLER_H_
 
 #include <set>
 #include <string>
 
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
+#include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 
-namespace base {
-class FilePath;
-};
-
 namespace content {
 
 class TracingController;
 
 // TracingController is used on the browser processes to enable/disable
 // trace status and collect trace data. Only the browser UI thread is allowed
 // to interact with the TracingController object. All callbacks are called on
 // the UI thread.
 class TracingController {
  public:
 
   CONTENT_EXPORT static TracingController* GetInstance();
 
+  // An interface for trace data consumer. An implemnentation of this interface
+  // is passed to either DisableTracing() or CaptureMonitoringSnapshot() and
+  // receives the trace data followed by a notification that all child processes
+  // have completed tracing and the data collection is over.
+  // All methods are called on the UI thread.
+  // Close method will be called exactly once and no methods will be
+  // called after that.
+  class CONTENT_EXPORT TraceDataSink
+      : public base::RefCountedThreadSafe<TraceDataSink> {

[jochen (gone - plz use gerrit), 2014/09/10 07:33:55]

why threadsafe if all happens on the UI thread?

+   public:
+    virtual void AddTraceChunk(const std::string& chunk) {}
+    virtual void SetSystemTrace(const std::string& data) {}
+    virtual void Close() {}
+   protected:
+    friend class base::RefCountedThreadSafe<TraceDataSink>;
+    virtual ~TraceDataSink() {}
+  };
+
+  // Create a trace sink that may be supplied to DisableRecording or
+  // CaptureMonitoringSnapshot to capture the trace data as a string.
+  CONTENT_EXPORT static scoped_refptr<TraceDataSink> CreateStringSink(
+      const base::Callback<void(base::RefCountedString*)>& callback);
+
+  // Create a trace sink that may be supplied to DisableRecording or
+  // CaptureMonitoringSnapshot to dump the trace data to a file.
+  CONTENT_EXPORT static scoped_refptr<TraceDataSink> CreateFileSink(
+      const base::FilePath& file_path, const base::Closure& callback);
+
   // Get a set of category groups. The category groups can change as
   // new code paths are reached.
   //
   // Once all child processes have acked to the GetCategories request,
   // GetCategoriesDoneCallback is called back with a set of category
   // groups.
   typedef base::Callback<void(const std::set<std::string>&)>
       GetCategoriesDoneCallback;
   virtual bool GetCategories(
       const GetCategoriesDoneCallback& callback) = 0;
@@ skipping 27 matching lines @@
   // Child processes typically are caching trace data and only rarely flush
   // and send trace data back to the browser process. That is because it may be
   // an expensive operation to send the trace data over IPC, and we would like
   // to avoid much runtime overhead of tracing. So, to end tracing, we must
   // asynchronously ask all child processes to flush any pending trace data.
   //
   // Once all child processes have acked to the DisableRecording request,
   // TracingFileResultCallback will be called back with a file that contains
   // the traced data.
   //
-  // Trace data will be written into |result_file_path| if it is not empty, or
-  // into a temporary file. The actual file path will be passed to |callback| if
-  // it's not null.
+  // If |trace_data_sink| is not null, it will receive chunks of trace data
+  // as a comma-separated sequences of JSON-stringified events, followed by
+  // a notification that the trace collection is finished.
   //
-  // If |result_file_path| is empty and |callback| is null, trace data won't be
-  // written to any file.
-  typedef base::Callback<void(const base::FilePath&)> TracingFileResultCallback;
-  virtual bool DisableRecording(const base::FilePath& result_file_path,
-                                const TracingFileResultCallback& callback) = 0;
+  virtual bool DisableRecording(
+      const scoped_refptr<TraceDataSink> &trace_data_sink) = 0;

[jochen (gone - plz use gerrit), 2014/09/10 07:33:56]

nit please clang-format (& should be before the space, not after)

 
   // Start monitoring on all processes.
   //
   // Monitoring begins immediately locally, and asynchronously on child
   // processes as soon as they receive the EnableMonitoring request.
   //
   // Once all child processes have acked to the EnableMonitoring request,
   // EnableMonitoringDoneCallback will be called back.
   //
   // |category_filter| is a filter to control what category groups should be
@@ skipping 25 matching lines @@
   // Child processes typically are caching trace data and only rarely flush
   // and send trace data back to the browser process. That is because it may be
   // an expensive operation to send the trace data over IPC, and we would like
   // to avoid much runtime overhead of tracing. So, to end tracing, we must
   // asynchronously ask all child processes to flush any pending trace data.
   //
   // Once all child processes have acked to the CaptureMonitoringSnapshot
   // request, TracingFileResultCallback will be called back with a file that
   // contains the traced data.
   //
-  // Trace data will be written into |result_file_path| if it is not empty, or
-  // into a temporary file. The actual file path will be passed to |callback|.
-  //
-  // If |result_file_path| is empty and |callback| is null, trace data won't be
-  // written to any file.
+  // If |trace_data_sink| is not null, it will receive chunks of trace data
+  // as a comma-separated sequences of JSON-stringified events, followed by
+  // a notification that the trace collection is finished.
   virtual bool CaptureMonitoringSnapshot(
-      const base::FilePath& result_file_path,
-      const TracingFileResultCallback& callback) = 0;
+      const scoped_refptr<TraceDataSink> &trace_data_sink) = 0;
 
   // Get the maximum across processes of trace buffer percent full state.
   // When the TraceBufferPercentFull value is determined, the callback is
   // called.
   typedef base::Callback<void(float)> GetTraceBufferPercentFullCallback;
   virtual bool GetTraceBufferPercentFull(
       const GetTraceBufferPercentFullCallback& callback) = 0;
 
   // |callback| will will be called every time the given event occurs on any
   // process.
   typedef base::Callback<void()> WatchEventCallback;
   virtual bool SetWatchEvent(const std::string& category_name,
                              const std::string& event_name,
                              const WatchEventCallback& callback) = 0;
 
   // Cancel the watch event. If tracing is enabled, this may race with the
   // watch event callback.
   virtual bool CancelWatchEvent() = 0;
 
  protected:
   virtual ~TracingController() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_TRACING_CONTROLLER_H_