Add support for CPU and heap profiles deletion.

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 113 matching lines @@
   unsigned GetUid() const;
 
   /** Returns CPU profile title. */
   Handle<String> GetTitle() const;
 
   /** Returns the root node of the bottom up call tree. */
   const CpuProfileNode* GetBottomUpRoot() const;
 
   /** Returns the root node of the top down call tree. */
   const CpuProfileNode* GetTopDownRoot() const;
+
+  /**
+   * Deletes the profile and removes it from CpuProfiler's list.
+   * All pointers to nodes previously returned become invalid.
+   * Profiles with the same uid but obtained using different
+   * security token are not deleted, but become inaccessible
+   * using FindProfile method. It is embedder's responsibility
+   * to call Delete on these profiles.
+   */
+  void Delete() const;

[Vitaly Repeshko, 2011/03/22 14:30:36]

"const" looks weird here.

[mnaganov (inactive), 2011/03/22 16:03:09]

Hmm, maybe. I added 'const' because all methods return const pointers (to
emphasize that embedder can't do much with them). So calling a non-const Delete
will require embedder to do a const_cast. But probably it's OK, as it attracts
more attention to calls to this method.

 };
 
 
 /**
  * Interface for controlling CPU profiling.
  */
 class V8EXPORT CpuProfiler {
  public:
   /**
    * A note on security tokens usage. As scripts from different
@@ skipping 30 matching lines @@
    */
   static void StartProfiling(Handle<String> title);
 
   /**
    * Stops collecting CPU profile with a given title and returns it.
    * If the title given is empty, finishes the last profile started.
    */
   static const CpuProfile* StopProfiling(
       Handle<String> title,
       Handle<Value> security_token = Handle<Value>());
+
+  /**
+   * Deletes all existing profiles, also cancelling all profiling
+   * activity.  All previously returned pointers to profiles and their
+   * contents become invalid after this call.
+   */
+  static void DeleteAllProfiles();
 };
 
 
 class HeapGraphNode;
 
 
 /**
  * HeapSnapshotEdge represents a directed connection between heap
  * graph nodes: from retaners to retained nodes.
  */
@@ skipping 167 matching lines @@
   /** Returns a node by its id. */
   const HeapGraphNode* GetNodeById(uint64_t id) 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;
 
   /**
+   * Deletes the snapshot and removes it from HeapProfiler's list.
+   * All pointers to nodes, edges and paths previously returned become
+   * invalid.
+   */
+  void Delete() const;

[Vitaly Repeshko, 2011/03/22 14:30:36]

Ditto.

[mnaganov (inactive), 2011/03/22 16:03:09]

Done.

+
+  /**
    * 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:
    *
    *  {
@@ skipping 39 matching lines @@
 
   /**
    * Takes a heap snapshot and returns it. Title may be an empty string.
    * See HeapSnapshot::Type for types description.
    */
   static const HeapSnapshot* TakeSnapshot(
       Handle<String> title,
       HeapSnapshot::Type type = HeapSnapshot::kFull,
       ActivityControl* control = NULL);
 
+  /**
+   * Deletes all snapshots taken. All previously returned pointers to
+   * snapshots and their contents become invalid after this call.
+   */
+  static void DeleteAllSnapshots();
+
   /** Binds a callback to embedder's class ID. */
   static void DefineWrapperClass(
       uint16_t class_id,
       WrapperInfoCallback callback);
 
   /**
    * Default value of persistent handle class ID. Must not be used to
    * define a class. Can be used to reset a class of a persistent
    * handle.
    */
@@ skipping 16 matching lines @@
  *
  * Thus, if an embedder wants to provide information about native
  * objects for heap snapshots, he can do it in a GC prologue
  * handler, and / or by assigning wrapper class ids in the following way:
  *
  *  1. Bind a callback to class id by calling DefineWrapperClass.
  *  2. Call SetWrapperClassId on certain persistent handles.
  *
  * V8 takes ownership of RetainedObjectInfo instances passed to it and
  * keeps them alive only during snapshot collection. Afterwards, they
- * are freed by calling the Dispose class function.
+ * are freed by calling the Delete class function.

[Vitaly Repeshko, 2011/03/22 14:30:36]

Accidental edit?

[mnaganov (inactive), 2011/03/22 16:03:09]

Ah, yes. Massive renaming. Reverted.

  */
 class V8EXPORT RetainedObjectInfo {  // NOLINT
  public:
   /** Called by V8 when it no longer needs an instance. */
   virtual void Dispose() = 0;
 
   /** Returns whether two instances are equivalent. */
   virtual bool IsEquivalent(RetainedObjectInfo* other) = 0;
 
   /**
@@ skipping 27 matching lines @@
 };
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 
 
 #endif  // V8_V8_PROFILER_H_