AllocationProfiler: introduce allocation_profiler flag in V8 api.

src/api.cc

 // 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 265 matching lines @@
 
 static inline bool EmptyCheck(const char* location, const v8::Data* obj) {
   return (obj == 0) ? ReportEmptyHandle(location) : false;
 }
 
 
 // --- S t a t i c s ---
 
 
 static bool InitializeHelper(i::Isolate* isolate) {
-  // If the isolate has a function entry hook, it needs to re-build all its
-  // code stubs with entry hooks embedded, so let's deserialize a snapshot.
-  if (isolate == NULL || isolate->function_entry_hook() == NULL) {
+  // If the isolate has a function entry hook or enabled allocation profiler,
+  // it needs to re-build all its code stubs with embedded entry hooks
+  // or RecordObjectAllocation calls, so let's skip snapshot deserialization.
+  if (isolate == NULL || (
+        isolate->function_entry_hook() == NULL &&
+        !isolate->is_allocation_profiler_enabled())) {
     if (i::Snapshot::Initialize())
       return true;
   }
   return i::V8::Initialize(NULL);
 }
 
 
 static inline bool EnsureInitializedForIsolate(i::Isolate* isolate,
                                                const char* location) {
   if (isolate != NULL) {
@@ skipping 4687 matching lines @@
   i::RandomNumberGenerator::SetEntropySource(entropy_source);
 }
 
 
 void v8::V8::SetReturnAddressLocationResolver(
       ReturnAddressLocationResolver return_address_resolver) {
   i::V8::SetReturnAddressLocationResolver(return_address_resolver);
 }
 
 
+bool v8::V8::EnableAllocationProfiler(Isolate* ext_isolate) {
+  ASSERT(ext_isolate != NULL);
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(ext_isolate);
+  return isolate->enable_allocation_profiler();
+}
+
+
+bool v8::V8::IsAllocationProfilerEnabled(Isolate* ext_isolate) {
+  ASSERT(ext_isolate != NULL);
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(ext_isolate);
+  return isolate->is_allocation_profiler_enabled();
+}
+
+
 bool v8::V8::SetFunctionEntryHook(Isolate* ext_isolate,
                                   FunctionEntryHook entry_hook) {
   ASSERT(ext_isolate != NULL);
   ASSERT(entry_hook != NULL);
 
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(ext_isolate);
 
   // The entry hook can only be set before the Isolate is initialized, as
   // otherwise the Isolate's code stubs generated at initialization won't
   // contain entry hooks.
@@ skipping 2565 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal