Introduce JIT code events dispatcher for the isolate.

src/profiler/profile-generator.cc

 // 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.
 
 #include "src/profiler/profile-generator.h"
 
 #include "src/ast/scopeinfo.h"
 #include "src/base/adapters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
@@ skipping 75 matching lines @@
   if (script_id_ != v8::UnboundScript::kNoScriptId) {
     return script_id_ == entry->script_id_ && position_ == entry->position_;
   }
   return name_prefix_ == entry->name_prefix_ && name_ == entry->name_ &&
          resource_name_ == entry->resource_name_ &&
          line_number_ == entry->line_number_;
 }
 
 
 void CodeEntry::SetBuiltinId(Builtins::Name id) {
-  bit_field_ = TagField::update(bit_field_, Logger::BUILTIN_TAG);
+  bit_field_ = TagField::update(bit_field_, CodeEventListener::BUILTIN_TAG);
   bit_field_ = BuiltinIdField::update(bit_field_, id);
 }
 
 
 int CodeEntry::GetSourceLine(int pc_offset) const {
   if (line_info_ && !line_info_->empty()) {
     return line_info_->GetSourceLineNumber(pc_offset);
   }
   return v8::CpuProfileNode::kNoLineNumberInfo;
 }
@@ skipping 154 matching lines @@
  public:
   void BeforeTraversingChild(ProfileNode*, ProfileNode*) { }
 
   void AfterAllChildrenTraversed(ProfileNode* node) {
     delete node;
   }
 
   void AfterChildTraversed(ProfileNode*, ProfileNode*) { }
 };
 
-
 ProfileTree::ProfileTree(Isolate* isolate)
-    : root_entry_(Logger::FUNCTION_TAG, "(root)"),
+    : root_entry_(CodeEventListener::FUNCTION_TAG, "(root)"),
       next_node_id_(1),
       root_(new ProfileNode(this, &root_entry_)),
       isolate_(isolate),
       next_function_id_(1),
       function_ids_(ProfileNode::CodeEntriesMatch) {}
 
-
 ProfileTree::~ProfileTree() {
   DeleteNodesCallback cb;
   TraverseDepthFirst(&cb);
 }
 
 
 unsigned ProfileTree::GetFunctionId(const ProfileNode* node) {
   CodeEntry* code_entry = node->entry();
   base::HashMap::Entry* entry =
       function_ids_.LookupOrInsert(code_entry, code_entry->GetHash());
@@ skipping 230 matching lines @@
   // As starting / stopping profiles is rare relatively to this
   // method, we don't bother minimizing the duration of lock holding,
   // e.g. copying contents of the list to a local vector.
   current_profiles_semaphore_.Wait();
   for (int i = 0; i < current_profiles_.length(); ++i) {
     current_profiles_[i]->AddPath(timestamp, path, src_line, update_stats);
   }
   current_profiles_semaphore_.Signal();
 }
 
-
 CodeEntry* CpuProfilesCollection::NewCodeEntry(
-    Logger::LogEventsAndTags tag, const char* name, const char* name_prefix,
-    const char* resource_name, int line_number, int column_number,
-    JITLineInfoTable* line_info, Address instruction_start) {
+    CodeEventListener::LogEventsAndTags tag, const char* name,
+    const char* name_prefix, const char* resource_name, int line_number,
+    int column_number, JITLineInfoTable* line_info, Address instruction_start) {
   CodeEntry* code_entry =
       new CodeEntry(tag, name, name_prefix, resource_name, line_number,
                     column_number, line_info, instruction_start);
   code_entries_.Add(code_entry);
   return code_entry;
 }
 
 
 const char* const ProfileGenerator::kProgramEntryName =
     "(program)";
 const char* const ProfileGenerator::kIdleEntryName =
     "(idle)";
 const char* const ProfileGenerator::kGarbageCollectorEntryName =
     "(garbage collector)";
 const char* const ProfileGenerator::kUnresolvedFunctionName =
     "(unresolved function)";
 
-
 ProfileGenerator::ProfileGenerator(CpuProfilesCollection* profiles)
     : profiles_(profiles),
-      program_entry_(
-          profiles->NewCodeEntry(Logger::FUNCTION_TAG, kProgramEntryName)),
-      idle_entry_(
-          profiles->NewCodeEntry(Logger::FUNCTION_TAG, kIdleEntryName)),
-      gc_entry_(
-          profiles->NewCodeEntry(Logger::BUILTIN_TAG,
-                                 kGarbageCollectorEntryName)),
-      unresolved_entry_(
-          profiles->NewCodeEntry(Logger::FUNCTION_TAG,
-                                 kUnresolvedFunctionName)) {
-}
-
+      program_entry_(profiles->NewCodeEntry(CodeEventListener::FUNCTION_TAG,
+                                            kProgramEntryName)),
+      idle_entry_(profiles->NewCodeEntry(CodeEventListener::FUNCTION_TAG,
+                                         kIdleEntryName)),
+      gc_entry_(profiles->NewCodeEntry(CodeEventListener::BUILTIN_TAG,
+                                       kGarbageCollectorEntryName)),
+      unresolved_entry_(profiles->NewCodeEntry(CodeEventListener::FUNCTION_TAG,
+                                               kUnresolvedFunctionName)) {}
 
 void ProfileGenerator::RecordTickSample(const TickSample& sample) {
   std::vector<CodeEntry*> entries;
   // Conservatively reserve space for stack frames + pc + function + vm-state.
   // There could in fact be more of them because of inlined entries.
   entries.reserve(sample.frames_count + 3);
 
   // The ProfileNode knows nothing about all versions of generated code for
   // the same JS function. The line number information associated with
   // the latest version of generated code is used to find a source line number
@@ skipping 106 matching lines @@
     case EXTERNAL:
       return program_entry_;
     case IDLE:
       return idle_entry_;
     default: return NULL;
   }
 }
 
 }  // namespace internal
 }  // namespace v8