Revert "CpuProfiler: eliminate 2 layers of 4 for CodeCreateEvent calls."

src/cpu-profiler.h

 // Copyright 2012 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 45 matching lines @@
  public:
 #define DECLARE_TYPE(type, ignore) type,
   enum Type {
     NONE = 0,
     CODE_EVENTS_TYPE_LIST(DECLARE_TYPE)
     NUMBER_OF_TYPES
   };
 #undef DECLARE_TYPE
 
   Type type;
-  mutable unsigned order;
+  unsigned order;
 };
 
 
 class CodeCreateEventRecord : public CodeEventRecord {
  public:
   Address start;
   CodeEntry* entry;
   unsigned size;
   Address shared;
 
@@ skipping 38 matching lines @@
   int filler;
   unsigned order;
   TickSample sample;
 
   static TickSampleEventRecord* cast(void* value) {
     return reinterpret_cast<TickSampleEventRecord*>(value);
   }
 };
 
 
-class CodeEventsContainer {
- public:
-  explicit CodeEventsContainer(
-      CodeEventRecord::Type type = CodeEventRecord::NONE) {
-    generic.type = type;
-  }
-  union  {
-    CodeEventRecord generic;
-#define DECLARE_CLASS(ignore, type) type type##_;
-    CODE_EVENTS_TYPE_LIST(DECLARE_CLASS)
-#undef DECLARE_TYPE
-  };
-};
-
-
 // This class implements both the profile events processor thread and
 // methods called by event producers: VM and stack sampler threads.
 class ProfilerEventsProcessor : public Thread {
  public:
   ProfilerEventsProcessor(ProfileGenerator* generator,
                           CpuProfilesCollection* profiles);
   virtual ~ProfilerEventsProcessor() {}
 
   // Thread control.
   virtual void Run();
   inline void Stop() { running_ = false; }
   INLINE(bool running()) { return running_; }
-  void Enqueue(const CodeEventsContainer& event);
 
+  // Events adding methods. Called by VM threads.
+  void CallbackCreateEvent(Logger::LogEventsAndTags tag,
+                           const char* prefix, Name* name,
+                           Address start);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       Name* name,
+                       String* resource_name, int line_number,
+                       Address start, unsigned size,
+                       Address shared,
+                       CompilationInfo* info);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       const char* name,
+                       Address start, unsigned size);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       int args_count,
+                       Address start, unsigned size);
+  void CodeMoveEvent(Address from, Address to);
+  void CodeDeleteEvent(Address from);
+  void SharedFunctionInfoMoveEvent(Address from, Address to);
+  void RegExpCodeCreateEvent(Logger::LogEventsAndTags tag,
+                             const char* prefix, String* name,
+                             Address start, unsigned size);
   // Puts current stack into tick sample events buffer.
   void AddCurrentStack();
 
   // Tick sample events are filled directly in the buffer of the circular
   // queue (because the structure is of fixed width, but usually not all
   // stack frame entries are filled.) This method returns a pointer to the
   // next record of the buffer.
   INLINE(TickSample* TickSampleEvent());
 
  private:
+  union CodeEventsContainer {
+    CodeEventRecord generic;
+#define DECLARE_CLASS(ignore, type) type type##_;
+    CODE_EVENTS_TYPE_LIST(DECLARE_CLASS)
+#undef DECLARE_TYPE
+  };
+
   // Called from events processing thread (Run() method.)
   bool ProcessCodeEvent(unsigned* dequeue_order);
   bool ProcessTicks(unsigned dequeue_order);
 
+  INLINE(static bool FilterOutCodeCreateEvent(Logger::LogEventsAndTags tag));
+
   ProfileGenerator* generator_;
   CpuProfilesCollection* profiles_;
   bool running_;
   UnboundQueue<CodeEventsContainer> events_buffer_;
   SamplingCircularQueue ticks_buffer_;
   UnboundQueue<TickSampleEventRecord> ticks_from_vm_buffer_;
   unsigned enqueue_order_;
 };
 
 
 #define PROFILE(IsolateGetter, Call)                                   \
   do {                                                                 \
     Isolate* cpu_profiler_isolate = (IsolateGetter);                   \
     LOG_CODE_EVENT(cpu_profiler_isolate, Call);                        \
     CpuProfiler* cpu_profiler = cpu_profiler_isolate->cpu_profiler();  \
     if (cpu_profiler->is_profiling()) {                                \
       cpu_profiler->Call;                                              \
     }                                                                  \
   } while (false)
 
 
 class CpuProfiler {
  public:
   explicit CpuProfiler(Isolate* isolate);
-
-  CpuProfiler(Isolate* isolate,
-              CpuProfilesCollection* test_collection,
-              ProfileGenerator* test_generator,
-              ProfilerEventsProcessor* test_processor);
-
   ~CpuProfiler();
 
   void StartProfiling(const char* title, bool record_samples = false);
   void StartProfiling(String* title, bool record_samples);
   CpuProfile* StopProfiling(const char* title);
   CpuProfile* StopProfiling(Object* security_token, String* title);
   int GetProfilesCount();
   CpuProfile* GetProfile(Object* security_token, int index);
   CpuProfile* FindProfile(Object* security_token, unsigned uid);
   void DeleteAllProfiles();
@@ skipping 52 matching lines @@
   bool is_profiling_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CpuProfiler);
 };
 
 } }  // namespace v8::internal
 
 
 #endif  // V8_CPU_PROFILER_H_