Add Scoped Context Info (Isolate) to V8 Traces

src/api.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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 40 matching lines @@
 #include "src/property.h"
 #include "src/property-descriptor.h"
 #include "src/property-details.h"
 #include "src/prototype.h"
 #include "src/runtime/runtime.h"
 #include "src/runtime-profiler.h"
 #include "src/simulator.h"
 #include "src/snapshot/natives.h"
 #include "src/snapshot/snapshot.h"
 #include "src/startup-data-util.h"
+#include "src/tracing/trace-event.h"
 #include "src/unicode-inl.h"
 #include "src/v8.h"
 #include "src/v8threads.h"
 #include "src/version.h"
 #include "src/vm-state-inl.h"
 
 
 namespace v8 {
 
 #define LOG_API(isolate, expr) LOG(isolate, ApiEntryCall(expr))
 
 
 #define ENTER_V8(isolate) i::VMState<v8::OTHER> __state__((isolate))
 
 
 #define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name, \
                                       bailout_value, HandleScopeClass, \
                                       do_callback)                     \
   if (IsExecutionTerminatingCheck(isolate)) {                          \
     return bailout_value;                                              \
   }                                                                    \
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);                \
   HandleScopeClass handle_scope(isolate);                              \
   CallDepthScope call_depth_scope(isolate, context, do_callback);      \
   LOG_API(isolate, function_name);                                     \
   ENTER_V8(isolate);                                                   \
   bool has_pending_exception = false
 
 
 #define PREPARE_FOR_EXECUTION_WITH_CONTEXT(                                  \
     context, function_name, bailout_value, HandleScopeClass, do_callback)    \
   auto isolate = context.IsEmpty()                                           \
@@ skipping 96 matching lines @@
   Local<Context> context_;
   bool escaped_;
   bool do_callback_;
 };
 
 }  // namespace
 
 
 static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,
                                              i::Handle<i::Script> script) {
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   i::Handle<i::Object> scriptName(i::Script::GetNameOrSourceURL(script));
   i::Handle<i::Object> source_map_url(script->source_mapping_url(), isolate);
   v8::Isolate* v8_isolate =
       reinterpret_cast<v8::Isolate*>(script->GetIsolate());
   ScriptOriginOptions options(script->origin_options());
   v8::ScriptOrigin origin(
       Utils::ToLocal(scriptName),
       v8::Integer::New(v8_isolate, script->line_offset()),
       v8::Integer::New(v8_isolate, script->column_offset()),
       v8::Boolean::New(v8_isolate, options.IsSharedCrossOrigin()),
@@ skipping 158 matching lines @@
 };
 
 }  // namespace
 
 
 StartupData V8::CreateSnapshotDataBlob(const char* custom_source) {
   i::Isolate* internal_isolate = new i::Isolate(true);
   ArrayBufferAllocator allocator;
   internal_isolate->set_array_buffer_allocator(&allocator);
   Isolate* isolate = reinterpret_cast<Isolate*>(internal_isolate);
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   StartupData result = {NULL, 0};
   {
     base::ElapsedTimer timer;
     timer.Start();
     Isolate::Scope isolate_scope(isolate);
     internal_isolate->Init(NULL);
     Persistent<Context> context;
     i::Snapshot::Metadata metadata;
     {
       HandleScope handle_scope(isolate);
@@ skipping 1457 matching lines @@
   auto context = v8_isolate->GetCurrentContext();
   RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, options), Script);
 }
 
 
 MaybeLocal<Script> ScriptCompiler::CompileModule(Local<Context> context,
                                                  Source* source,
                                                  CompileOptions options) {
   CHECK(i::FLAG_harmony_modules);
   auto isolate = context->GetIsolate();
+  TRACE_EVENT_SCOPED_CONTEXT("V8", "Isolate", isolate);
   auto maybe = CompileUnboundInternal(isolate, source, options, true);
   Local<UnboundScript> generic;
   if (!maybe.ToLocal(&generic)) return MaybeLocal<Script>();
   v8::Context::Scope scope(context);
   return generic->BindToCurrentContext();
 }
 
 
 class IsIdentifierHelper {
  public:
@@ skipping 406 matching lines @@
 void v8::TryCatch::SetCaptureMessage(bool value) {
   capture_message_ = value;
 }
 
 
 // --- M e s s a g e ---
 
 
 Local<String> Message::Get() const {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   ENTER_V8(isolate);
   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   i::Handle<i::String> raw_result = i::MessageHandler::GetMessage(isolate, obj);
   Local<String> result = Utils::ToLocal(raw_result);
   return scope.Escape(result);
 }
 
 
 ScriptOrigin Message::GetScriptOrigin() const {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
   auto script_wraper = i::Handle<i::Object>(message->script(), isolate);
   auto script_value = i::Handle<i::JSValue>::cast(script_wraper);
   i::Handle<i::Script> script(i::Script::cast(script_value->value()));
   return GetScriptOriginForScript(isolate, script);
 }
 
 
 v8::Local<Value> Message::GetScriptResourceName() const {
   return GetScriptOrigin().ResourceName();
 }
 
 
 v8::Local<v8::StackTrace> Message::GetStackTrace() const {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   ENTER_V8(isolate);
   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
   auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
   i::Handle<i::Object> stackFramesObj(message->stack_frames(), isolate);
   if (!stackFramesObj->IsJSArray()) return v8::Local<v8::StackTrace>();
   auto stackTrace = i::Handle<i::JSArray>::cast(stackFramesObj);
   return scope.Escape(Utils::StackTraceToLocal(stackTrace));
 }
 
 
@@ skipping 3188 matching lines @@
   // Leave V8.
 
   return env;
 }
 
 Local<Context> v8::Context::New(v8::Isolate* external_isolate,
                                 v8::ExtensionConfiguration* extensions,
                                 v8::Local<ObjectTemplate> global_template,
                                 v8::Local<Value> global_object) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   LOG_API(isolate, "Context::New");
   i::HandleScope scope(isolate);
   ExtensionConfiguration no_extensions;
   if (extensions == NULL) extensions = &no_extensions;
   i::Handle<i::Context> env =
       CreateEnvironment(isolate, extensions, global_template, global_object);
   if (env.is_null()) {
     if (isolate->has_pending_exception()) {
       isolate->OptionalRescheduleException(true);
     }
@@ skipping 1618 matching lines @@
 
 Isolate* Isolate::GetCurrent() {
   i::Isolate* isolate = i::Isolate::Current();
   return reinterpret_cast<Isolate*>(isolate);
 }
 
 
 Isolate* Isolate::New(const Isolate::CreateParams& params) {
   i::Isolate* isolate = new i::Isolate(false);
   Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   CHECK(params.array_buffer_allocator != NULL);
   isolate->set_array_buffer_allocator(params.array_buffer_allocator);
   if (params.snapshot_blob != NULL) {
     isolate->set_snapshot_blob(params.snapshot_blob);
   } else {
     isolate->set_snapshot_blob(i::Snapshot::DefaultSnapshotBlob());
   }
   if (params.entry_hook) {
     isolate->set_function_entry_hook(params.entry_hook);
   }
@@ skipping 1393 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8