Implement heap snapshots serialization into JSON. API is designed

include/v8-profiler.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 305 matching lines @@
 
 
 /**
  * HeapSnapshots record the state of the JS heap at some moment.
  */
 class V8EXPORT HeapSnapshot {
  public:
   enum Type {
     kFull = 0,       // Heap snapshot with all instances and references.
     kAggregated = 1  // Snapshot doesn't contain individual heap entries,
-                     //instead they are grouped by constructor name.
+                     // instead they are grouped by constructor name.
+  };
+  enum SerializationFormat {
+    kJSON = 0  // See format description near 'Serialize' method.
   };
 
   /** Returns heap snapshot type. */
   Type GetType() const;
 
   /** Returns heap snapshot UID (assigned by the profiler.) */
   unsigned GetUid() const;
 
   /** Returns heap snapshot title. */
   Handle<String> GetTitle() const;
 
   /** Returns the root node of the heap graph. */
   const HeapGraphNode* GetRoot() const;
 
   /**
    * Returns a diff between this snapshot and another one. Only snapshots
    * of the same type can be compared.
    */
   const HeapSnapshotsDiff* CompareWith(const HeapSnapshot* snapshot) const;
+
+  /**
+   * Prepare a serialized representation of the snapshot. The result
+   * is written into the stream provided in chunks of specified size.
+   * The total length of the serialized snapshot is unknown in
+   * advance, it is can be roughly equal to JS heap size (that means,
+   * it can be really big - tens of megabytes).
+   *
+   * For the JSON format, heap contents are represented as an object
+   * with the following structure:
+   *
+   *  {
+   *    snapshot: {title: "...", uid: nnn},
+   *    nodes: [
+   *      meta-info (JSON string),
+   *      nodes themselves
+   *    ],
+   *    strings: [strings]
+   *  }
+   *
+   * Outgoing node links are stored after each node. Nodes reference strings
+   * and other nodes by their indexes in corresponding arrays.
+   */
+  void Serialize(OutputStream* stream, SerializationFormat format) const;
 };
 
 
 /**
  * Interface for controlling heap profiling.
  */
 class V8EXPORT HeapProfiler {
  public:
   /** Returns the number of snapshots taken. */
   static int GetSnapshotsCount();
@@ skipping 14 matching lines @@
 };
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 
 
 #endif  // V8_V8_PROFILER_H_