Integrate Chrome tracing with V8 (WIP)

src/log.h

 // 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.
 
 #ifndef V8_LOG_H_
 #define V8_LOG_H_
 
 #include <string>
 
 #include "src/allocation.h"
@@ skipping 134 matching lines @@
 
 class JitLogger;
 class PerfBasicLogger;
 class LowLevelLogger;
 class PerfJitLogger;
 class Sampler;
 
 class Logger {
  public:
   enum StartEnd { START = 0, END = 1 };
+  enum Overhead { LOW = 0, NORMAL = 1, HIGH = 2 };
 
 #define DECLARE_ENUM(enum_item, ignore) enum_item,
   enum LogEventsAndTags {
     LOG_EVENTS_AND_TAGS_LIST(DECLARE_ENUM)
     NUMBER_OF_LOG_EVENTS
   };
 #undef DECLARE_ENUM
 
   // Acquires resources for logging if the right flags are set.
   bool SetUp(Isolate* isolate);
@@ skipping 131 matching lines @@
   void CurrentTimeEvent();
 
   void TimerEvent(StartEnd se, const char* name);
 
   static void EnterExternal(Isolate* isolate);
   static void LeaveExternal(Isolate* isolate);
 
   static void DefaultEventLoggerSentinel(const char* name, int event) {}
 
   INLINE(static void CallEventLogger(Isolate* isolate, const char* name,
-                                     StartEnd se, bool expose_to_api));
+                                     StartEnd se, Overhead overhead));
 
   // ==== Events logged by --log-regexp ====
   // Regexp compilation and execution events.
 
   void RegExpCompileEvent(Handle<JSRegExp> regexp, bool in_cache);
 
   bool is_logging() {
     return is_logging_;
   }
 
@@ skipping 98 matching lines @@
   // Guards against multiple calls to TearDown() that can happen in some tests.
   // 'true' between SetUp() and TearDown().
   bool is_initialized_;
 
   base::ElapsedTimer timer_;
 
   friend class CpuProfiler;
 };
 
 
-#define TIMER_EVENTS_LIST(V)    \
-  V(RecompileSynchronous, true) \
-  V(RecompileConcurrent, true)  \
-  V(CompileFullCode, true)      \
-  V(Execute, true)              \
-  V(External, true)             \
-  V(IcMiss, false)
+#define TIMER_EVENTS_LIST(V)      \
+  V(RecompileSynchronous, NORMAL) \
+  V(RecompileConcurrent, NORMAL)  \
+  V(CompileFullCode, NORMAL)      \
+  V(Execute, NORMAL)              \
+  V(External, NORMAL)             \
+  V(IcMiss, HIGH)
 
-#define V(TimerName, expose)                                                  \
+#define V(TimerName, TimerOverhead)                                           \
   class TimerEvent##TimerName : public AllStatic {                            \
    public:                                                                    \
     static const char* name(void* unused = NULL) { return "V8." #TimerName; } \
-    static bool expose_to_api() { return expose; }                            \
+    static Logger::Overhead overhead() { return Logger::TimerOverhead; }      \
   };
 TIMER_EVENTS_LIST(V)
 #undef V
 
 
 template <class TimerEvent>
 class TimerEventScope {
  public:
   explicit TimerEventScope(Isolate* isolate) : isolate_(isolate) {
     LogTimerEvent(Logger::START);
@@ skipping 86 matching lines @@
                                  int length) = 0;
 
   NameBuffer* name_buffer_;
 };
 
 
 } }  // namespace v8::internal
 
 
 #endif  // V8_LOG_H_