Revert of [profiler] Update cpu profile tracing format.

src/profiler/profile-generator.cc

 // Copyright 2012 the V8 project 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 "src/profiler/profile-generator.h"
 
 #include "src/base/adapters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/global-handles.h"
@@ skipping 394 matching lines @@
     : title_(title),
       record_samples_(record_samples),
       start_time_(base::TimeTicks::HighResolutionNow()),
       top_down_(profiler->isolate()),
       profiler_(profiler),
       streaming_next_sample_(0) {
   auto value = TracedValue::Create();
   value->SetDouble("startTime",
                    (start_time_ - base::TimeTicks()).InMicroseconds());
   TRACE_EVENT_SAMPLE_WITH_ID1(TRACE_DISABLED_BY_DEFAULT("v8.cpu_profiler"),
-                              "Profile", this, "data", std::move(value));
+                              "CpuProfile", this, "data", std::move(value));
 }
 
 void CpuProfile::AddPath(base::TimeTicks timestamp,
                          const std::vector<CodeEntry*>& path, int src_line,
                          bool update_stats) {
   ProfileNode* top_frame_node =
       top_down_.AddPathFromEnd(path, src_line, update_stats);
   if (record_samples_ && !timestamp.IsNull()) {
     timestamps_.Add(timestamp);
     samples_.Add(top_frame_node);
@@ skipping 33 matching lines @@
   }
 }
 
 }  // namespace
 
 void CpuProfile::StreamPendingTraceEvents() {
   std::vector<const ProfileNode*> pending_nodes = top_down_.TakePendingNodes();
   if (pending_nodes.empty() && !samples_.length()) return;
   auto value = TracedValue::Create();
 
-  if (!pending_nodes.empty() || streaming_next_sample_ != samples_.length()) {
-    value->BeginDictionary("cpuProfile");
-    if (!pending_nodes.empty()) {
-      value->BeginArray("nodes");
-      for (auto node : pending_nodes) {
-        value->BeginDictionary();
-        BuildNodeValue(node, value.get());
-        value->EndDictionary();
-      }
-      value->EndArray();
+  if (!pending_nodes.empty()) {
+    value->BeginArray("nodes");
+    for (auto node : pending_nodes) {
+      value->BeginDictionary();
+      BuildNodeValue(node, value.get());
+      value->EndDictionary();
     }
-    if (streaming_next_sample_ != samples_.length()) {
-      value->BeginArray("samples");
-      for (int i = streaming_next_sample_; i < samples_.length(); ++i) {
-        value->AppendInteger(samples_[i]->id());
-      }
-      value->EndArray();
+    value->EndArray();
+  }
+
+  if (streaming_next_sample_ != samples_.length()) {
+    value->BeginArray("samples");
+    for (int i = streaming_next_sample_; i < samples_.length(); ++i) {
+      value->AppendInteger(samples_[i]->id());
     }
-    value->EndDictionary();
-  }
-  if (streaming_next_sample_ != samples_.length()) {
+    value->EndArray();
     value->BeginArray("timeDeltas");
     base::TimeTicks lastTimestamp =
         streaming_next_sample_ ? timestamps_[streaming_next_sample_ - 1]
                                : start_time();
     for (int i = streaming_next_sample_; i < timestamps_.length(); ++i) {
       value->AppendInteger(
           static_cast<int>((timestamps_[i] - lastTimestamp).InMicroseconds()));
       lastTimestamp = timestamps_[i];
     }
     value->EndArray();
     DCHECK(samples_.length() == timestamps_.length());
     streaming_next_sample_ = samples_.length();
   }
 
   TRACE_EVENT_SAMPLE_WITH_ID1(TRACE_DISABLED_BY_DEFAULT("v8.cpu_profiler"),
-                              "ProfileChunk", this, "data", std::move(value));
+                              "CpuProfileChunk", this, "data",
+                              std::move(value));
 }
 
 void CpuProfile::FinishProfile() {
   end_time_ = base::TimeTicks::HighResolutionNow();
   StreamPendingTraceEvents();
   auto value = TracedValue::Create();
   value->SetDouble("endTime", (end_time_ - base::TimeTicks()).InMicroseconds());
   TRACE_EVENT_SAMPLE_WITH_ID1(TRACE_DISABLED_BY_DEFAULT("v8.cpu_profiler"),
-                              "ProfileChunk", this, "data", std::move(value));
+                              "CpuProfileChunk", this, "data",
+                              std::move(value));
 }
 
 void CpuProfile::Print() {
   base::OS::Print("[Top down]:\n");
   top_down_.Print();
 }
 
 void CodeMap::AddCode(Address addr, CodeEntry* entry, unsigned size) {
   DeleteAllCoveredCode(addr, addr + size);
   code_map_.insert({addr, CodeEntryInfo(entry, size)});
@@ skipping 245 matching lines @@
     case EXTERNAL:
       return CodeEntry::program_entry();
     case IDLE:
       return CodeEntry::idle_entry();
     default: return NULL;
   }
 }
 
 }  // namespace internal
 }  // namespace v8