Additional context creation tracing

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

 /*
  * Copyright (C) 2008, 2009, 2011 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:
  *
  *     * 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
@@ skipping 228 matching lines @@
     ScriptState::Scope scope(m_scriptState.get());
     v8::Local<v8::Context> context = m_scriptState->context();
     if (m_global.isEmpty()) {
         m_global.set(m_isolate, context->Global());
         if (m_global.isEmpty()) {
             disposeContext(DoNotDetachGlobal);
             return false;
         }
     }
 
-    if (!setupWindowPrototypeChain()) {
-        disposeContext(DoNotDetachGlobal);
-        return false;
+    {
+        TRACE_EVENT0("v8", "WindowProxy::initialize (prototype chain)");
+        if (!setupWindowPrototypeChain()) {
+            disposeContext(DoNotDetachGlobal);
+            return false;
+        }
     }
 
-    SecurityOrigin* origin = 0;
-    if (m_world->isMainWorld()) {
-        // ActivityLogger for main world is updated within updateDocument().
-        updateDocument();
-        origin = m_frame->securityContext()->getSecurityOrigin();
-        // FIXME: Can this be removed when CSP moves to browser?
-        ContentSecurityPolicy* csp = m_frame->securityContext()->contentSecurityPolicy();
-        context->AllowCodeGenerationFromStrings(csp->allowEval(0, ContentSecurityPolicy::SuppressReport));
-        context->SetErrorMessageForCodeGenerationFromStrings(v8String(m_isolate, csp->evalDisabledErrorMessage()));
-    } else {
-        updateActivityLogger();
-        origin = m_world->isolatedWorldSecurityOrigin();
-        setSecurityToken(origin);
-    }
-    if (m_frame->isLocalFrame()) {
-        LocalFrame* frame = toLocalFrame(m_frame);
-        MainThreadDebugger::instance()->contextCreated(m_scriptState.get(), frame, origin);
-        frame->loader().client()->didCreateScriptContext(context, m_world->extensionGroup(), m_world->worldId());
+    {
+        TRACE_EVENT0("v8", "WindowProxy::initialize (misc init)");
+        SecurityOrigin* origin = 0;
+        if (m_world->isMainWorld()) {
+            // ActivityLogger for main world is updated within updateDocument().
+            updateDocument();
+            origin = m_frame->securityContext()->getSecurityOrigin();
+            // FIXME: Can this be removed when CSP moves to browser?
+            ContentSecurityPolicy* csp = m_frame->securityContext()->contentSecurityPolicy();
+            context->AllowCodeGenerationFromStrings(csp->allowEval(0, ContentSecurityPolicy::SuppressReport));
+            context->SetErrorMessageForCodeGenerationFromStrings(v8String(m_isolate, csp->evalDisabledErrorMessage()));
+        } else {
+            updateActivityLogger();
+            origin = m_world->isolatedWorldSecurityOrigin();
+            setSecurityToken(origin);
+        }
+        if (m_frame->isLocalFrame()) {
+            LocalFrame* frame = toLocalFrame(m_frame);
+            MainThreadDebugger::instance()->contextCreated(m_scriptState.get(), frame, origin);
+            TRACE_EVENT0("v8", "WindowProxy::initialize (did create script context)");
+            frame->loader().client()->didCreateScriptContext(context, m_world->extensionGroup(), m_world->worldId());
+        }
     }
     // If Origin Trials have been registered before the V8 context was ready,
     // then inject them into the context now
     if (m_world->isMainWorld()) {
         ExecutionContext* executionContext = m_scriptState->getExecutionContext();
         if (executionContext) {
+            TRACE_EVENT0("v8", "WindowProxy::initialize (origin trial init)");
             OriginTrialContext* originTrialContext = OriginTrialContext::from(executionContext);
             if (originTrialContext)
                 originTrialContext->initializePendingFeatures();
         }
     }
     return true;
 }
 
 void WindowProxy::createContext()
 {
@@ skipping 26 matching lines @@
             if (!frame->loader().client()->allowScriptExtension(extension->name(), extensionGroup, worldId))
                 continue;
 
             extensionNames.append(extension->name());
         }
     }
     v8::ExtensionConfiguration extensionConfiguration(extensionNames.size(), extensionNames.data());
 
     v8::Local<v8::Context> context;
     {
+        TRACE_EVENT0("v8", "WindowProxy::createContext");
         V8PerIsolateData::UseCounterDisabledScope useCounterDisabled(V8PerIsolateData::from(m_isolate));
         context = v8::Context::New(m_isolate, &extensionConfiguration, globalTemplate, m_global.newLocal(m_isolate));
     }
     if (context.IsEmpty())
         return;
     m_scriptState = ScriptState::create(context, m_world);
 }
 
 bool WindowProxy::setupWindowPrototypeChain()
 {
@@ skipping 50 matching lines @@
 }
 
 void WindowProxy::updateDocumentWrapper(v8::Local<v8::Object> wrapper)
 {
     ASSERT(m_world->isMainWorld());
     m_document.set(m_isolate, wrapper);
 }
 
 void WindowProxy::updateDocumentProperty()
 {
+    TRACE_EVENT0("v8", "WindowProxy::updateDocumentProperty");
     if (!m_world->isMainWorld())
         return;
 
     if (m_frame->isRemoteFrame()) {
         return;
     }
 
     ScriptState::Scope scope(m_scriptState.get());
     v8::Local<v8::Context> context = m_scriptState->context();
     LocalFrame* frame = toLocalFrame(m_frame);
     v8::Local<v8::Value> documentWrapper = toV8(frame->document(), context->Global(), context->GetIsolate());
     if (documentWrapper.IsEmpty())
         return;
     ASSERT(documentWrapper == m_document.newLocal(m_isolate) || m_document.isEmpty());
     if (m_document.isEmpty())
         updateDocumentWrapper(v8::Local<v8::Object>::Cast(documentWrapper));
     checkDocumentWrapper(m_document.newLocal(m_isolate), frame->document());
 
     ASSERT(documentWrapper->IsObject());
     // TODO(jochen): Don't replace the accessor with a data value. We need a way to tell v8 that the accessor's return value won't change after this point.
     if (!v8CallBoolean(context->Global()->ForceSet(context, v8AtomicString(m_isolate, "document"), documentWrapper, static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))))
         return;
 }
 
 void WindowProxy::updateActivityLogger()
 {
+    TRACE_EVENT0("v8", "WindowProxy::updateActivityLogger");
     m_scriptState->perContextData()->setActivityLogger(V8DOMActivityLogger::activityLogger(
         m_world->worldId(), m_frame->isLocalFrame() && toLocalFrame(m_frame)->document() ? toLocalFrame(m_frame)->document()->baseURI() : KURL()));
 }
 
 void WindowProxy::setSecurityToken(SecurityOrigin* origin)
 {
     // If two tokens are equal, then the SecurityOrigins canAccess each other.
     // If two tokens are not equal, then we have to call canAccess.
     // Note: we can't use the HTTPOrigin if it was set from the DOM.
     String token;
@@ skipping 37 matching lines @@
     }
 
     CString utf8Token = token.utf8();
     // NOTE: V8 does identity comparison in fast path, must use a symbol
     // as the security token.
     context->SetSecurityToken(v8AtomicString(m_isolate, utf8Token.data(), utf8Token.length()));
 }
 
 void WindowProxy::updateDocument()
 {
+    TRACE_EVENT0("v8", "WindowProxy::updateDocument");
     ASSERT(m_world->isMainWorld());
     if (!isGlobalInitialized())
         return;
     if (!isContextInitialized())
         return;
     updateActivityLogger();
     updateDocumentProperty();
     updateSecurityOrigin(m_frame->securityContext()->getSecurityOrigin());
 }
 
@@ skipping 62 matching lines @@
 
     ScriptState::Scope scope(m_scriptState.get());
     ASSERT(!m_document.isEmpty());
     v8::Local<v8::Object> documentHandle = m_document.newLocal(m_isolate);
     checkDocumentWrapper(documentHandle, document);
     documentHandle->Delete(m_isolate->GetCurrentContext(), v8String(m_isolate, name));
 }
 
 void WindowProxy::updateSecurityOrigin(SecurityOrigin* origin)
 {
+    TRACE_EVENT0("v8", "WindowProxy::updateSecurityOrigin");
     if (!isContextInitialized())
         return;
     setSecurityToken(origin);
 }
 
 } // namespace blink