WIP: The tracing service prototype

content/browser/tracing/tracing_controller_impl_data_sinks.cc

 // Copyright 2015 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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/pattern.h"
 #include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/zlib/zlib.h"
 
 namespace content {
 
 namespace {
 
-const char kChromeTraceLabel[] = "traceEvents";
-const char kMetadataTraceLabel[] = "metadata";
-
 class StringTraceDataEndpoint : public TraceDataEndpoint {
  public:
   typedef base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)>
       CompletionCallback;
 
   explicit StringTraceDataEndpoint(CompletionCallback callback)
       : completion_callback_(callback) {}
 
   void ReceiveTraceFinalContents(
@@ skipping 103 matching lines @@
  private:
   std::map<std::string, std::string> additional_tracing_agent_trace_;
   std::unique_ptr<base::DictionaryValue> metadata_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceDataSinkImplBase);
 };
 
 class JSONTraceDataSink : public TraceDataSinkImplBase {
  public:
   explicit JSONTraceDataSink(scoped_refptr<TraceDataEndpoint> endpoint)
-      : endpoint_(endpoint), had_received_first_chunk_(false) {}
+      : endpoint_(endpoint) {}
 
   void AddTraceChunk(const std::string& chunk) override {
-    std::string trace_string;
-    if (had_received_first_chunk_)
-      trace_string = ",";
-    else
-      trace_string = "{\"" + std::string(kChromeTraceLabel) + "\":[";
-    trace_string += chunk;
-    had_received_first_chunk_ = true;
-
-    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>(trace_string));
+    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>(chunk));
   }
 
   void Close() override {
-    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>("]"));
-
-    for (auto const &it : GetAgentTrace())
-      endpoint_->ReceiveTraceChunk(
-          base::MakeUnique<std::string>(",\"" + it.first + "\": " + it.second));
-
     std::unique_ptr<base::DictionaryValue> metadata(TakeMetadata());
-    std::string metadataJSON;
-
-    if (base::JSONWriter::Write(*metadata, &metadataJSON) &&
-        !metadataJSON.empty()) {
-      endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>(
-          ",\"" + std::string(kMetadataTraceLabel) + "\": " + metadataJSON));
-    }
-
-    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>("}"));
     endpoint_->ReceiveTraceFinalContents(std::move(metadata));
   }
 
  private:
   ~JSONTraceDataSink() override {}
 
   scoped_refptr<TraceDataEndpoint> endpoint_;
-  bool had_received_first_chunk_;
   DISALLOW_COPY_AND_ASSIGN(JSONTraceDataSink);
 };
 
 class CompressedTraceDataEndpoint : public TraceDataEndpoint {
  public:
   explicit CompressedTraceDataEndpoint(
       scoped_refptr<TraceDataEndpoint> endpoint)
       : endpoint_(endpoint), already_tried_open_(false) {}
 
   void ReceiveTraceChunk(std::unique_ptr<std::string> chunk) override {
@@ skipping 142 matching lines @@
   return new StringTraceDataEndpoint(callback);
 }
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingControllerImpl::CreateJSONSink(
     scoped_refptr<TraceDataEndpoint> endpoint) {
   return new JSONTraceDataSink(endpoint);
 }
 
 }  // namespace content