Make logger use new sampling API for ticks and code events.

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 211 matching lines @@
   void addCodeEventListener(CodeEventListener* listener);
   void removeCodeEventListener(CodeEventListener* listener);
   bool hasCodeEventListener(CodeEventListener* listener);
 
 
   // Emits a code event for a callback function.
   void CallbackEvent(Name* name, Address entry_point);
   void GetterCallbackEvent(Name* name, Address entry_point);
   void SetterCallbackEvent(Name* name, Address entry_point);
   // Emits a code create event.
+  void CodeCreateEvent(const v8::JitCodeEvent* event);
   void CodeCreateEvent(LogEventsAndTags tag,
                        Code* code, const char* source);
   void CodeCreateEvent(LogEventsAndTags tag,
                        Code* code, Name* name);
   void CodeCreateEvent(LogEventsAndTags tag,
                        Code* code,
                        SharedFunctionInfo* shared,
                        CompilationInfo* info,
                        Name* name);
   void CodeCreateEvent(LogEventsAndTags tag,
                        Code* code,
                        SharedFunctionInfo* shared,
                        CompilationInfo* info,
                        Name* source, int line, int column);
   void CodeCreateEvent(LogEventsAndTags tag, Code* code, int args_count);
   // Emits a code deoptimization event.
   void CodeDisableOptEvent(Code* code, SharedFunctionInfo* shared);
   void CodeMovingGCEvent();
   // Emits a code create event for a RegExp.
   void RegExpCodeCreateEvent(Code* code, String* source);
-  // Emits a code move event.
+  // Emit a code move event.
+  void CodeMoveEvent(const v8::JitCodeEvent* event);
   void CodeMoveEvent(Address from, Address to);
-  // Emits a code delete event.
+  // Emit a code delete event.
+  void CodeDeleteEvent(const v8::JitCodeEvent* event);
   void CodeDeleteEvent(Address from);
   // Emits a code line info add event with Postion type.
   void CodeLinePosInfoAddPositionEvent(void* jit_handler_data,
                                        int pc_offset,
                                        int position);
   // Emits a code line info add event with StatementPostion type.
   void CodeLinePosInfoAddStatementPositionEvent(void* jit_handler_data,
                                                 int pc_offset,
                                                 int position);
   // Emits a code line info start to record event
@@ skipping 57 matching lines @@
     static const char* v8_compile_full_code;
     static const char* v8_execute;
     static const char* v8_external;
     static const char* v8_ic_miss;
 
    private:
     Isolate* isolate_;
     const char* name_;
   };
 
+
+  class SamplerThread : public v8::base::Thread {
+   public:
+    explicit SamplerThread(v8::Isolate* isolate);
+    virtual ~SamplerThread();
+    virtual void Run();
+
+   private:
+    static void JitCodeEventHandler(const v8::JitCodeEvent* event);
+    v8::Isolate* isolate_;
+    bool done_sampling_;
+  };
+
+
   // ==== Events logged by --log-regexp ====
   // Regexp compilation and execution events.
 
   void RegExpCompileEvent(Handle<JSRegExp> regexp, bool in_cache);
 
   bool is_logging() {
     return is_logging_;
   }
 
   bool is_logging_code_events() {
@@ skipping 46 matching lines @@
   // Emits the source code of a regexp. Used by regexp events.
   void LogRegExpSource(Handle<JSRegExp> regexp);
 
   // Used for logging stubs found in the snapshot.
   void LogCodeObject(Object* code_object);
 
   // Helper method. It resets name_buffer_ and add tag name into it.
   void InitNameBuffer(LogEventsAndTags tag);
 
   // Emits a profiler tick event. Used by the profiler thread.
-  void TickEvent(TickSample* sample, bool overflow);
+  void TickEvent(TickSample* sample, bool overflow) {}
+
+  void LogSample(v8::Sample* sample);
 
   void ApiEvent(const char* name, ...);
 
   // Logs a StringEvent regardless of whether FLAG_log is true.
   void UncheckedStringEvent(const char* name, const char* value);
 
   // Logs an IntEvent regardless of whether FLAG_log is true.
   void UncheckedIntEvent(const char* name, int value);
   void UncheckedIntPtrTEvent(const char* name, intptr_t value);
 
@@ skipping 19 matching lines @@
   template <StateTag Tag> friend class VMState;
   friend class LoggerTestHelper;
 
   bool is_logging_;
   Log* log_;
   PerfBasicLogger* perf_basic_logger_;
   PerfJitLogger* perf_jit_logger_;
   LowLevelLogger* ll_logger_;
   JitLogger* jit_logger_;
   List<CodeEventListener*> listeners_;
+  SamplerThread* sampler_thread_;
 
   // 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;
 };
 
@@ skipping 76 matching lines @@
                                  int length) = 0;
 
   NameBuffer* name_buffer_;
 };
 
 
 } }  // namespace v8::internal
 
 
 #endif  // V8_LOG_H_