Tracing: re-use JSONTraceDataSink in DevTools' tracing handler...

content/browser/devtools/protocol/tracing_handler.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/devtools/protocol/tracing_handler.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 74 matching lines @@
     if (TracingHandler* h = tracing_handler_.get())
       h->OnTraceComplete();
   }
 
  private:
   ~DevToolsTraceSinkProxy() override {}
 
   base::WeakPtr<TracingHandler> tracing_handler_;
 };
 
-class DevToolsStreamTraceSink : public TracingController::TraceDataSink {
+class DevToolsStreamEndpoint : public TraceDataEndpoint {
  public:
-  explicit DevToolsStreamTraceSink(
+  explicit DevToolsStreamEndpoint(
       base::WeakPtr<TracingHandler> handler,
       const scoped_refptr<DevToolsIOContext::Stream>& stream)
-      : stream_(stream),
-        tracing_handler_(handler),
-        first_chunk_(true) {}
+      : stream_(stream), tracing_handler_(handler) {}
 
-  void AddTraceChunk(const std::string& chunk) override {
-    // FIXME: change interface to pass chunks as refcounted strings.
-    scoped_refptr<base::RefCountedString> ref_counted_chunk
-        = new base::RefCountedString();
-    std::string prefix = first_chunk_ ? "[" : ",";
-    ref_counted_chunk->data() = prefix + chunk;
-    first_chunk_ = false;
-    stream_->Append(ref_counted_chunk);
+  void ReceiveTraceChunk(std::unique_ptr<std::string> chunk) override {
+    stream_->Append(std::move(chunk));
   }
 
-  void Close() override {
-    if (TracingHandler* h = tracing_handler_.get()) {
-      std::string suffix = "]";
-      stream_->Append(base::RefCountedString::TakeString(&suffix));
+  void ReceiveTraceFinalContents(
+      std::unique_ptr<const base::DictionaryValue> metadata) override {
+    if (TracingHandler* h = tracing_handler_.get())
       h->OnTraceToStreamComplete(stream_->handle());
-    }
   }
 
  private:
-  ~DevToolsStreamTraceSink() override {}
+  ~DevToolsStreamEndpoint() override {}
 
   scoped_refptr<DevToolsIOContext::Stream> stream_;
   base::WeakPtr<TracingHandler> tracing_handler_;
-  bool first_chunk_;
 };
 
 }  // namespace
 
 TracingHandler::TracingHandler(TracingHandler::Target target,
                                int frame_tree_node_id,
                                DevToolsIOContext* io_context)
     : target_(target),
       io_context_(io_context),
       frame_tree_node_id_(frame_tree_node_id),
@@ skipping 76 matching lines @@
   return target_ == Renderer ? Response::FallThrough() : Response::OK();
 }
 
 Response TracingHandler::End(DevToolsCommandId command_id) {
   // Startup tracing triggered by --trace-config-file is a special case, where
   // tracing is started automatically upon browser startup and can be stopped
   // via DevTools.
   if (!did_initiate_recording_ && !IsStartupTracingActive())
     return Response::InternalError("Tracing is not started");
 
-  scoped_refptr<TracingController::TraceDataSink> proxy;
+  scoped_refptr<TracingController::TraceDataSink> sink;
   if (return_as_stream_) {
-    proxy = new DevToolsStreamTraceSink(
-        weak_factory_.GetWeakPtr(), io_context_->CreateTempFileBackedStream());
+    sink = TracingControllerImpl::CreateJSONSink(new DevToolsStreamEndpoint(
+        weak_factory_.GetWeakPtr(), io_context_->CreateTempFileBackedStream()));
   } else {
-    proxy = new DevToolsTraceSinkProxy(weak_factory_.GetWeakPtr());
+    sink = new DevToolsTraceSinkProxy(weak_factory_.GetWeakPtr());
   }
-  StopTracing(proxy);
+  StopTracing(sink);
   // If inspected target is a render process Tracing.end will be handled by
   // tracing agent in the renderer.
   return target_ == Renderer ? Response::FallThrough() : Response::OK();
 }
 
 Response TracingHandler::GetCategories(DevToolsCommandId command_id) {
   TracingController::GetInstance()->GetCategories(
       base::Bind(&TracingHandler::OnCategoriesReceived,
                  weak_factory_.GetWeakPtr(),
                  command_id));
@@ skipping 106 matching lines @@
   std::string mode;
   if (tracing_dict->GetString(kRecordModeParam, &mode))
     tracing_dict->SetString(kRecordModeParam, ConvertFromCamelCase(mode, '-'));
 
   return base::trace_event::TraceConfig(*tracing_dict);
 }
 
 }  // namespace tracing
 }  // namespace devtools
 }  // namespace content