Clean up public TracingController interface [1/3]: hide TraceDataEndpoint

content/browser/tracing/tracing_controller_impl.h

 // Copyright (c) 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_BROWSER_TRACING_TRACING_CONTROLLER_IMPL_H_
 #define CONTENT_BROWSER_TRACING_TRACING_CONTROLLER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 12 matching lines @@
 namespace base {
 class RefCountedString;
 class RefCountedMemory;
 }
 
 namespace content {
 
 class TraceMessageFilter;
 class TracingUI;
 
+// An implementation of this interface is passed when constructing a
+// TraceDataSink, and receives chunks of the final trace data as it's being
+// constructed.
+// Methods may be called from any thread.
+class TraceDataEndpoint : public base::RefCountedThreadSafe<TraceDataEndpoint> {
+ public:
+  virtual void ReceiveTraceChunk(const std::string& chunk) {}
+  virtual void ReceiveTraceFinalContents(
+      std::unique_ptr<const base::DictionaryValue> metadata,
+      const std::string& contents) {}
+
+ protected:
+  friend class base::RefCountedThreadSafe<TraceDataEndpoint>;
+  virtual ~TraceDataEndpoint() {}
+};
+
 class TracingControllerImpl
     : public TracingController,
       public base::trace_event::MemoryDumpManagerDelegate,
       public base::trace_event::TracingAgent {
  public:
+  // Create an endpoint that may be supplied to any TraceDataSink to
+  // dump the trace data to a callback.
+  CONTENT_EXPORT static scoped_refptr<TraceDataEndpoint> CreateCallbackEndpoint(
+      const base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                                base::RefCountedString*)>& callback);
+
+  // Create an endpoint that may be supplied to any TraceDataSink to
+  // dump the trace data to a file.
+  CONTENT_EXPORT static scoped_refptr<TraceDataEndpoint> CreateFileEndpoint(
+      const base::FilePath& file_path,
+      const base::Closure& callback);
+
+  CONTENT_EXPORT static scoped_refptr<TraceDataSink> CreateCompressedStringSink(
+      scoped_refptr<TraceDataEndpoint> endpoint);
+
   static TracingControllerImpl* GetInstance();
 
   // TracingController implementation.
   bool GetCategories(const GetCategoriesDoneCallback& callback) override;
   bool StartTracing(const base::trace_event::TraceConfig& trace_config,
                     const StartTracingDoneCallback& callback) override;
   bool StopTracing(const scoped_refptr<TraceDataSink>& sink) override;
   bool GetTraceBufferUsage(
       const GetTraceBufferUsageCallback& callback) override;
   bool SetWatchEvent(const std::string& category_name,
@@ skipping 175 matching lines @@
   std::set<TracingUI*> tracing_uis_;
   scoped_refptr<TraceDataSink> trace_data_sink_;
   scoped_refptr<TraceDataSink> monitoring_data_sink_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingControllerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_TRACING_TRACING_CONTROLLER_IMPL_H_