Add probe for V8.Complie

third_party/WebKit/Source/bindings/core/v8/V8ScriptRunner.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 398 matching lines @@
   DCHECK(!resource->ErrorOccurred());
   DCHECK(streamer->IsFinished());
   DCHECK(!streamer->StreamingSuppressed());
   return WTF::Bind(PostStreamCompile, cache_options,
                    WrapPersistent(resource->CacheHandler()),
                    WrapPersistent(streamer));
 }
 }  // namespace
 
 v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript(
+    ExecutionContext* context,
     const ScriptSourceCode& source,
     v8::Isolate* isolate,
     AccessControlStatus access_control_status,
     V8CacheOptions cache_options) {
   if (source.Source().length() >= v8::String::kMaxLength) {
     V8ThrowException::ThrowError(isolate, "Source file too large.");
     return v8::Local<v8::Script>();
   }
   return CompileScript(
-      V8String(isolate, source.Source()), source.Url(), source.SourceMapUrl(),
-      source.StartPosition(), isolate, source.GetResource(), source.Streamer(),
+      context, V8String(isolate, source.Source()), source.Url(),
+      source.SourceMapUrl(), source.StartPosition(), isolate,
+      source.GetResource(), source.Streamer(),
       source.GetResource() ? source.GetResource()->CacheHandler() : nullptr,
       access_control_status, cache_options);
 }
 
 v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript(
+    ExecutionContext* context,
     const String& code,
     const String& file_name,
     const String& source_map_url,
     const TextPosition& text_position,
     v8::Isolate* isolate,
     CachedMetadataHandler* cache_metadata_handler,
     AccessControlStatus access_control_status,
     V8CacheOptions v8_cache_options) {
   if (code.length() >= v8::String::kMaxLength) {
     V8ThrowException::ThrowError(isolate, "Source file too large.");
     return v8::Local<v8::Script>();
   }
-  return CompileScript(V8String(isolate, code), file_name, source_map_url,
-                       text_position, isolate, nullptr, nullptr,
+  return CompileScript(context, V8String(isolate, code), file_name,
+                       source_map_url, text_position, isolate, nullptr, nullptr,
                        cache_metadata_handler, access_control_status,
                        v8_cache_options);
 }
 
 v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript(
+    ExecutionContext* context,
     v8::Local<v8::String> code,
     const String& file_name,
     const String& source_map_url,
     const TextPosition& script_start_position,
     v8::Isolate* isolate,
     ScriptResource* resource,
     ScriptStreamer* streamer,
     CachedMetadataHandler* cache_handler,
     AccessControlStatus access_control_status,
     V8CacheOptions cache_options) {
   TRACE_EVENT2(
       "v8,devtools.timeline", "v8.compile", "fileName", file_name.Utf8(),
       "data",
       InspectorCompileScriptEvent::Data(file_name, script_start_position));
+  probe::V8Compile probe(context, file_name,
+                         script_start_position.line_.ZeroBasedInt(),
+                         script_start_position.column_.ZeroBasedInt());
 
   DCHECK(!streamer || resource);
   DCHECK(!resource || resource->CacheHandler() == cache_handler);
 
   // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
   // 1, whereas v8 starts at 0.
   v8::ScriptOrigin origin(
       V8String(isolate, file_name),
       v8::Integer::New(isolate, script_start_position.line_.ZeroBasedInt()),
       v8::Integer::New(isolate, script_start_position.column_.ZeroBasedInt()),
@@ skipping 96 matching lines @@
                                          v8::MicrotasksScope::kRunMicrotasks);
     probe::ExecuteScript probe(context);
     result = script->Run(isolate->GetCurrentContext());
   }
 
   CHECK(!isolate->IsDead());
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::CompileAndRunInternalScript(
+    ExecutionContext* context,
     v8::Local<v8::String> source,
     v8::Isolate* isolate,
     const String& file_name,
     const TextPosition& script_start_position) {
   v8::Local<v8::Script> script;
-  if (!V8ScriptRunner::CompileScript(
-           source, file_name, String(), script_start_position, isolate, nullptr,
-           nullptr, nullptr, kSharableCrossOrigin, kV8CacheOptionsDefault)
+  if (!V8ScriptRunner::CompileScript(context, source, file_name, String(),
+                                     script_start_position, isolate, nullptr,
+                                     nullptr, nullptr, kSharableCrossOrigin,
+                                     kV8CacheOptionsDefault)
            .ToLocal(&script))
     return v8::MaybeLocal<v8::Value>();
 
   TRACE_EVENT0("v8", "v8.run");
   RuntimeCallStatsScopedTracer rcs_scoped_tracer(isolate);
   RUNTIME_CALL_TIMER_SCOPE(isolate, RuntimeCallStats::CounterId::kV8);
   v8::MicrotasksScope microtasks_scope(
       isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
   v8::MaybeLocal<v8::Value> result = script->Run(isolate->GetCurrentContext());
   CHECK(!isolate->IsDead());
@@ skipping 180 matching lines @@
   if (!context->GetExtrasBindingObject()
            ->Get(context, V8AtomicString(isolate, name))
            .ToLocal(&function_value))
     return v8::MaybeLocal<v8::Value>();
   v8::Local<v8::Function> function = function_value.As<v8::Function>();
   return V8ScriptRunner::CallInternalFunction(function, v8::Undefined(isolate),
                                               num_args, args, isolate);
 }
 
 }  // namespace blink