Isolatify CPU profiler public API

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 117 matching lines @@
   unsigned GetUid() const;
 
   /** Returns CPU profile title. */
   Handle<String> GetTitle() const;
 
   /** Returns the root node of the top down call tree. */
   const CpuProfileNode* GetTopDownRoot() const;
 
   /**
     * Returns number of samples recorded. The samples are not recorded unless
-    * |record_samples| parameter of CpuProfiler::StartProfiling is true.
+    * |record_samples| parameter of CpuProfiler::StartCpuProfiling is true.
     */
   int GetSamplesCount() const;
 
   /**
     * Returns profile node corresponding to the top frame the sample at
     * the given index.
     */
   const CpuProfileNode* GetSample(int index) 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();
 };
 
 
 /**
- * Interface for controlling CPU profiling.
+ * Interface for controlling CPU profiling. Instance of the
+ * profiler can be retrieved using v8::Isolate::GetCpuProfiler.
  */
 class V8EXPORT CpuProfiler {
  public:
   /**
    * A note on security tokens usage. As scripts from different
    * origins can run inside a single V8 instance, it is possible to
    * have functions from different security contexts intermixed in a
    * single CPU profile. To avoid exposing function names belonging to
    * other contexts, filtering by security token is performed while
    * obtaining profiling results.
    */
 
+  /** Deprecated. Use GetProfileCount instead. */
+  static int GetProfilesCount();
   /**
    * Returns the number of profiles collected (doesn't include
    * profiles that are being collected at the moment of call.)
    */
-  static int GetProfilesCount();
+  int GetProfileCount();
 
-  /** Returns a profile by index. */
+  /** Deprecated. Use GetCpuProfile instead. */
   static const CpuProfile* GetProfile(
       int index,
       Handle<Value> security_token = Handle<Value>());
+  /** Returns a profile by index. */
+  const CpuProfile* GetCpuProfile(
+      int index,
+      Handle<Value> security_token = Handle<Value>());
 
-  /** Returns a profile by uid. */
+  /** Deprecated. Use FindProfile instead. */
   static const CpuProfile* FindProfile(
       unsigned uid,
       Handle<Value> security_token = Handle<Value>());
+  /** Returns a profile by uid. */
+  const CpuProfile* FindCpuProfile(
+      unsigned uid,
+      Handle<Value> security_token = Handle<Value>());
 
+  /** Deprecated. Use StartCpuProfiling instead. */
+  static void StartProfiling(Handle<String> title, bool record_samples = false);
   /**
    * Starts collecting CPU profile. Title may be an empty string. It
    * is allowed to have several profiles being collected at
    * once. Attempts to start collecting several profiles with the same
    * title are silently ignored. While collecting a profile, functions
    * from all security contexts are included in it. The token-based
    * filtering is only performed when querying for a profile.
    *
    * |record_samples| parameter controls whether individual samples should
    * be recorded in addition to the aggregated tree.
    */
-  static void StartProfiling(Handle<String> title, bool record_samples = false);
+  void StartCpuProfiling(Handle<String> title, bool record_samples = false);
 
+  /** Deprecated. Use StopCpuProfiling instead. */
+  static const CpuProfile* StopProfiling(
+      Handle<String> title,
+      Handle<Value> security_token = Handle<Value>());
   /**
    * 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(
+  const CpuProfile* StopCpuProfiling(
       Handle<String> title,
       Handle<Value> security_token = Handle<Value>());
 
+  /** Deprecated. Use DeleteAllCpuProfiles instead. */
+  static void DeleteAllProfiles();
   /**
    * 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();
+  void DeleteAllCpuProfiles();
+
+ private:
+  CpuProfiler();
+  ~CpuProfiler();
+  CpuProfiler(const CpuProfiler&);
+  CpuProfiler& operator=(const CpuProfiler&);
 };
 
 
 class HeapGraphNode;
 
 
 /**
  * HeapSnapshotEdge represents a directed connection between heap
  * graph nodes: from retainers to retained nodes.
  */
@@ skipping 395 matching lines @@
 };
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 
 
 #endif  // V8_V8_PROFILER_H_