Revert of Revert of Reland factor out window proxy management portions of ScriptController.

Source/bindings/core/v8/ScriptController.cpp

 /*
  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Opera Software ASA. 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
@@ skipping 29 matching lines @@
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8Event.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8HTMLElement.h"
 #include "bindings/core/v8/V8NPObject.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "bindings/core/v8/V8Window.h"
 #include "bindings/core/v8/WindowProxy.h"
+#include "bindings/core/v8/WindowProxyManager.h"
 #include "bindings/core/v8/npruntime_impl.h"
 #include "bindings/core/v8/npruntime_priv.h"
 #include "core/dom/Document.h"
 #include "core/dom/Node.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/events/Event.h"
 #include "core/events/EventListener.h"
 #include "core/frame/LocalDOMWindow.h"
-#include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
@@ skipping 16 matching lines @@
 
 bool ScriptController::canAccessFromCurrentOrigin(LocalFrame *frame)
 {
     if (!frame)
         return false;
     v8::Isolate* isolate = toIsolate(frame);
     return !isolate->InContext() || BindingSecurity::shouldAllowAccessToFrame(isolate, frame);
 }
 
 ScriptController::ScriptController(LocalFrame* frame)
-    : m_frame(frame)
+    : m_windowProxyManager(WindowProxyManager::create(frame))
     , m_sourceURL(0)
-    , m_isolate(v8::Isolate::GetCurrent())
-    , m_windowProxy(WindowProxy::create(frame, DOMWrapperWorld::mainWorld(), m_isolate))
     , m_windowScriptNPObject(0)
 {
 }
 
 ScriptController::~ScriptController()
 {
 }
 
 void ScriptController::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
-    visitor->trace(m_frame);
-    visitor->trace(m_windowProxy);
-    visitor->trace(m_isolatedWorlds);
+    visitor->trace(m_windowProxyManager);
 #endif
 }
 
 void ScriptController::clearScriptObjects()
 {
     PluginObjectMap::iterator it = m_pluginObjects.begin();
     for (; it != m_pluginObjects.end(); ++it) {
         _NPN_UnregisterObject(it->value);
         _NPN_ReleaseObject(it->value);
     }
     m_pluginObjects.clear();
 
     if (m_windowScriptNPObject) {
         // Dispose of the underlying V8 object before releasing our reference
         // to it, so that if a plugin fails to release it properly we will
         // only leak the NPObject wrapper, not the object, its document, or
         // anything else they reference.
-        disposeUnderlyingV8Object(m_isolate, m_windowScriptNPObject);
+        disposeUnderlyingV8Object(isolate(), m_windowScriptNPObject);
         _NPN_ReleaseObject(m_windowScriptNPObject);
         m_windowScriptNPObject = 0;
     }
 }
 
 void ScriptController::clearForClose()
 {
     double start = currentTime();
-    m_windowProxy->clearForClose();
-    for (IsolatedWorldMap::iterator iter = m_isolatedWorlds.begin(); iter != m_isolatedWorlds.end(); ++iter)
-        iter->value->clearForClose();
+    m_windowProxyManager->clearForClose();
     blink::Platform::current()->histogramCustomCounts("WebCore.ScriptController.clearForClose", (currentTime() - start) * 1000, 0, 10000, 50);
 }
 
 void ScriptController::updateSecurityOrigin(SecurityOrigin* origin)
 {
-    m_windowProxy->updateSecurityOrigin(origin);
+    m_windowProxyManager->mainWorldProxy()->updateSecurityOrigin(origin);
 }
 
 v8::Local<v8::Value> ScriptController::callFunction(v8::Handle<v8::Function> function, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> info[])
 {
     // Keep LocalFrame (and therefore ScriptController) alive.
-    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
-    return ScriptController::callFunction(m_frame->document(), function, receiver, argc, info, m_isolate);
+    RefPtrWillBeRawPtr<LocalFrame> protect(frame());
+    return ScriptController::callFunction(frame()->document(), function, receiver, argc, info, isolate());
 }
 
 v8::Local<v8::Value> ScriptController::callFunction(ExecutionContext* context, v8::Handle<v8::Function> function, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> info[], v8::Isolate* isolate)
 {
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "FunctionCall", "data", devToolsTraceEventData(isolate, context, function));
     // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
     InspectorInstrumentationCookie cookie;
     if (InspectorInstrumentation::hasFrontends()) {
         int scriptId = 0;
         String resourceName;
         int lineNumber = 1;
         GetDevToolsFunctionInfo(function, isolate, scriptId, resourceName, lineNumber);
         cookie = InspectorInstrumentation::willCallFunction(context, scriptId, resourceName, lineNumber);
     }
 
     v8::Local<v8::Value> result = V8ScriptRunner::callFunction(function, context, receiver, argc, info, isolate);
 
     InspectorInstrumentation::didCallFunction(cookie);
     return result;
 }
 
 v8::Local<v8::Value> ScriptController::executeScriptAndReturnValue(v8::Handle<v8::Context> context, const ScriptSourceCode& source, AccessControlStatus corsStatus, double* compilationFinishTime)
 {
-    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "EvaluateScript", "data", InspectorEvaluateScriptEvent::data(m_frame, source.url().string(), source.startLine()));
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "EvaluateScript", "data", InspectorEvaluateScriptEvent::data(frame(), source.url().string(), source.startLine()));
     // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
-    InspectorInstrumentationCookie cookie = InspectorInstrumentation::willEvaluateScript(m_frame, source.url().string(), source.startLine());
+    InspectorInstrumentationCookie cookie = InspectorInstrumentation::willEvaluateScript(frame(), source.url().string(), source.startLine());
 
     v8::Local<v8::Value> result;
     {
         V8CacheOptions v8CacheOptions(V8CacheOptionsDefault);
-        if (m_frame->settings())
-            v8CacheOptions = m_frame->settings()->v8CacheOptions();
+        if (frame()->settings())
+            v8CacheOptions = frame()->settings()->v8CacheOptions();
 
         // Isolate exceptions that occur when compiling and executing
         // the code. These exceptions should not interfere with
         // javascript code we might evaluate from C++ when returning
         // from here.
         v8::TryCatch tryCatch;
         tryCatch.SetVerbose(true);
 
-        v8::Handle<v8::Script> script = V8ScriptRunner::compileScript(source, m_isolate, corsStatus, v8CacheOptions);
+        v8::Handle<v8::Script> script = V8ScriptRunner::compileScript(source, isolate(), corsStatus, v8CacheOptions);
 
         if (compilationFinishTime) {
             *compilationFinishTime = WTF::monotonicallyIncreasingTime();
         }
         // Keep LocalFrame (and therefore ScriptController) alive.
-        RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
-        result = V8ScriptRunner::runCompiledScript(m_isolate, script, m_frame->document());
+        RefPtrWillBeRawPtr<LocalFrame> protect(frame());
+        result = V8ScriptRunner::runCompiledScript(isolate(), script, frame()->document());
         ASSERT(!tryCatch.HasCaught() || result.IsEmpty());
     }
 
     InspectorInstrumentation::didEvaluateScript(cookie);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", "data", InspectorUpdateCountersEvent::data());
 
     return result;
 }
 
 bool ScriptController::initializeMainWorld()
 {
-    if (m_windowProxy->isContextInitialized())
+    if (m_windowProxyManager->mainWorldProxy()->isContextInitialized())
         return false;
     return windowProxy(DOMWrapperWorld::mainWorld())->isContextInitialized();
 }
 
 WindowProxy* ScriptController::existingWindowProxy(DOMWrapperWorld& world)
 {
-    if (world.isMainWorld())
-        return m_windowProxy->isContextInitialized() ? m_windowProxy.get() : 0;
-
-    IsolatedWorldMap::iterator iter = m_isolatedWorlds.find(world.worldId());
-    if (iter == m_isolatedWorlds.end())
-        return 0;
-    return iter->value->isContextInitialized() ? iter->value.get() : 0;
+    return m_windowProxyManager->existingWindowProxy(world);
 }
 
 WindowProxy* ScriptController::windowProxy(DOMWrapperWorld& world)
 {
-    WindowProxy* windowProxy = nullptr;
-    if (world.isMainWorld()) {
-        windowProxy = m_windowProxy.get();
-    } else {
-        IsolatedWorldMap::iterator iter = m_isolatedWorlds.find(world.worldId());
-        if (iter != m_isolatedWorlds.end()) {
-            windowProxy = iter->value.get();
-        } else {
-            OwnPtrWillBeRawPtr<WindowProxy> isolatedWorldWindowProxy = WindowProxy::create(m_frame, world, m_isolate);
-            windowProxy = isolatedWorldWindowProxy.get();
-            m_isolatedWorlds.set(world.worldId(), isolatedWorldWindowProxy.release());
-        }
-    }
+    WindowProxy* windowProxy = m_windowProxyManager->windowProxy(world);
     if (!windowProxy->isContextInitialized() && windowProxy->initializeIfNeeded() && world.isMainWorld())
-        m_frame->loader().dispatchDidClearWindowObjectInMainWorld();
+        frame()->loader().dispatchDidClearWindowObjectInMainWorld();
+    // FIXME: There are some situations where we can return an uninitialized
+    // context. This is broken.
     return windowProxy;
 }
 
 bool ScriptController::shouldBypassMainWorldCSP()
 {
-    v8::HandleScope handleScope(m_isolate);
-    v8::Handle<v8::Context> context = m_isolate->GetCurrentContext();
+    v8::HandleScope handleScope(isolate());
+    v8::Handle<v8::Context> context = isolate()->GetCurrentContext();
     if (context.IsEmpty() || !toDOMWindow(context))
         return false;
-    DOMWrapperWorld& world = DOMWrapperWorld::current(m_isolate);
+    DOMWrapperWorld& world = DOMWrapperWorld::current(isolate());
     return world.isIsolatedWorld() ? world.isolatedWorldHasContentSecurityPolicy() : false;
 }
 
 TextPosition ScriptController::eventHandlerPosition() const
 {
-    ScriptableDocumentParser* parser = m_frame->document()->scriptableDocumentParser();
+    ScriptableDocumentParser* parser = frame()->document()->scriptableDocumentParser();
     if (parser)
         return parser->textPosition();
     return TextPosition::minimumPosition();
 }
 
 // Create a V8 object with an interceptor of NPObjectPropertyGetter.
 void ScriptController::bindToWindowObject(LocalFrame* frame, const String& key, NPObject* object)
 {
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState->contextIsValid())
         return;
 
     ScriptState::Scope scope(scriptState);
-    v8::Handle<v8::Object> value = createV8ObjectForNPObject(m_isolate, object, 0);
+    v8::Handle<v8::Object> value = createV8ObjectForNPObject(isolate(), object, 0);
 
     // Attach to the global object.
-    scriptState->context()->Global()->Set(v8String(m_isolate, key), value);
+    scriptState->context()->Global()->Set(v8String(isolate(), key), value);
 }
 
 void ScriptController::enableEval()
 {
-    if (!m_windowProxy->isContextInitialized())
+    if (!m_windowProxyManager->mainWorldProxy()->isContextInitialized())
         return;
-    v8::HandleScope handleScope(m_isolate);
-    m_windowProxy->context()->AllowCodeGenerationFromStrings(true);
+    v8::HandleScope handleScope(isolate());
+    m_windowProxyManager->mainWorldProxy()->context()->AllowCodeGenerationFromStrings(true);
 }
 
 void ScriptController::disableEval(const String& errorMessage)
 {
-    if (!m_windowProxy->isContextInitialized())
+    if (!m_windowProxyManager->mainWorldProxy()->isContextInitialized())
         return;
-    v8::HandleScope handleScope(m_isolate);
-    v8::Local<v8::Context> v8Context = m_windowProxy->context();
+    v8::HandleScope handleScope(isolate());
+    v8::Local<v8::Context> v8Context = m_windowProxyManager->mainWorldProxy()->context();
     v8Context->AllowCodeGenerationFromStrings(false);
-    v8Context->SetErrorMessageForCodeGenerationFromStrings(v8String(m_isolate, errorMessage));
+    v8Context->SetErrorMessageForCodeGenerationFromStrings(v8String(isolate(), errorMessage));
 }
 
 PassRefPtr<SharedPersistent<v8::Object> > ScriptController::createPluginWrapper(Widget* widget)
 {
     ASSERT(widget);
 
     if (!widget->isPluginView())
         return nullptr;
 
-    v8::HandleScope handleScope(m_isolate);
-    v8::Local<v8::Object> scriptableObject = toPluginView(widget)->scriptableObject(m_isolate);
+    v8::HandleScope handleScope(isolate());
+    v8::Local<v8::Object> scriptableObject = toPluginView(widget)->scriptableObject(isolate());
 
     if (scriptableObject.IsEmpty())
         return nullptr;
 
     // LocalFrame Memory Management for NPObjects
     // -------------------------------------
     // NPObjects are treated differently than other objects wrapped by JS.
     // NPObjects can be created either by the browser (e.g. the main
     // window object) or by the plugin (the main plugin object
     // for a HTMLEmbedElement). Further, unlike most DOM Objects, the frame
@@ skipping 13 matching lines @@
     //
     // Inside the javascript engine, the engine can keep a reference to the
     // NPObject as part of its wrapper. However, before accessing the object
     // it must consult the _NPN_Registry.
 
     if (isWrappedNPObject(scriptableObject)) {
         // Track the plugin object. We've been given a reference to the object.
         m_pluginObjects.set(widget, v8ObjectToNPObject(scriptableObject));
     }
 
-    return SharedPersistent<v8::Object>::create(scriptableObject, m_isolate);
+    return SharedPersistent<v8::Object>::create(scriptableObject, isolate());
 }
 
 void ScriptController::cleanupScriptObjectsForPlugin(Widget* nativeHandle)
 {
     PluginObjectMap::iterator it = m_pluginObjects.find(nativeHandle);
     if (it == m_pluginObjects.end())
         return;
     _NPN_UnregisterObject(it->value);
     _NPN_ReleaseObject(it->value);
     m_pluginObjects.remove(it);
@@ skipping 36 matching lines @@
 }
 
 NPObject* ScriptController::windowScriptNPObject()
 {
     if (m_windowScriptNPObject)
         return m_windowScriptNPObject;
 
     if (canExecuteScripts(NotAboutToExecuteScript)) {
         // JavaScript is enabled, so there is a JavaScript window object.
         // Return an NPObject bound to the window object.
-        m_windowScriptNPObject = createScriptObject(m_frame, m_isolate);
+        m_windowScriptNPObject = createScriptObject(frame(), isolate());
         _NPN_RegisterObject(m_windowScriptNPObject, 0);
     } else {
         // JavaScript is not enabled, so we cannot bind the NPObject to the
         // JavaScript window object. Instead, we create an NPObject of a
         // different class, one which is not bound to a JavaScript object.
         m_windowScriptNPObject = createNoScriptObject();
     }
     return m_windowScriptNPObject;
 }
 
 NPObject* ScriptController::createScriptObjectForPluginElement(HTMLPlugInElement* plugin)
 {
     // Can't create NPObjects when JavaScript is disabled.
     if (!canExecuteScripts(NotAboutToExecuteScript))
         return createNoScriptObject();
 
-    ScriptState* scriptState = ScriptState::forMainWorld(m_frame);
+    ScriptState* scriptState = ScriptState::forMainWorld(frame());
     if (!scriptState->contextIsValid())
         return createNoScriptObject();
 
     ScriptState::Scope scope(scriptState);
-    LocalDOMWindow* window = m_frame->localDOMWindow();
+    LocalDOMWindow* window = frame()->localDOMWindow();
     v8::Handle<v8::Value> v8plugin = toV8(plugin, scriptState->context()->Global(), scriptState->isolate());
     if (!v8plugin->IsObject())
         return createNoScriptObject();
 
     return npCreateV8ScriptObject(scriptState->isolate(), 0, v8::Handle<v8::Object>::Cast(v8plugin), window);
 }
 
 void ScriptController::clearWindowProxy()
 {
-    double start = currentTime();
     // V8 binding expects ScriptController::clearWindowProxy only be called
     // when a frame is loading a new page. This creates a new context for the new page.
 
+    double start = currentTime();
     // The V8 context must be available for |clearScriptObjects()|.
     // The below call must be before |clearForNavigation()| which disposes the V8 context.
     clearScriptObjects();
-    m_windowProxy->clearForNavigation();
-    for (IsolatedWorldMap::iterator iter = m_isolatedWorlds.begin(); iter != m_isolatedWorlds.end(); ++iter)
-        iter->value->clearForNavigation();
+
+    m_windowProxyManager->clearForNavigation();
     blink::Platform::current()->histogramCustomCounts("WebCore.ScriptController.clearWindowProxy", (currentTime() - start) * 1000, 0, 10000, 50);
 }
 
 void ScriptController::setCaptureCallStackForUncaughtExceptions(bool value)
 {
     v8::V8::SetCaptureStackTraceForUncaughtExceptions(value, ScriptCallStack::maxCallStackSizeToCapture, stackTraceOptions);
 }
 
 void ScriptController::collectIsolatedContexts(Vector<std::pair<ScriptState*, SecurityOrigin*> >& result)
 {
-    for (IsolatedWorldMap::iterator it = m_isolatedWorlds.begin(); it != m_isolatedWorlds.end(); ++it) {
-        WindowProxy* isolatedWorldWindowProxy = it->value.get();
-        SecurityOrigin* origin = isolatedWorldWindowProxy->world().isolatedWorldSecurityOrigin();
-        if (!isolatedWorldWindowProxy->isContextInitialized())
-            continue;
-        result.append(std::pair<ScriptState*, SecurityOrigin*>(isolatedWorldWindowProxy->scriptState(), origin));
-    }
+    m_windowProxyManager->collectIsolatedContexts(result);
 }
 
 void ScriptController::setWorldDebugId(int worldId, int debuggerId)
 {
-    ASSERT(debuggerId > 0);
-    bool isMainWorld = worldId == MainWorldId;
-    WindowProxy* windowProxy = 0;
-    if (isMainWorld) {
-        windowProxy = m_windowProxy.get();
-    } else {
-        IsolatedWorldMap::iterator iter = m_isolatedWorlds.find(worldId);
-        if (iter != m_isolatedWorlds.end())
-            windowProxy = iter->value.get();
-    }
-    if (!windowProxy || !windowProxy->isContextInitialized())
-        return;
-    v8::HandleScope scope(m_isolate);
-    v8::Local<v8::Context> context = windowProxy->context();
-    const char* worldName = isMainWorld ? "page" : "injected";
-    V8PerContextDebugData::setContextDebugData(context, worldName, debuggerId);
+    m_windowProxyManager->setWorldDebugId(worldId, debuggerId);
 }
 
 void ScriptController::updateDocument()
 {
     // For an uninitialized main window windowProxy, do not incur the cost of context initialization.
-    if (!m_windowProxy->isGlobalInitialized())
+    if (!m_windowProxyManager->mainWorldProxy()->isGlobalInitialized())
         return;
 
     if (!initializeMainWorld())
         windowProxy(DOMWrapperWorld::mainWorld())->updateDocument();
 }
 
 void ScriptController::namedItemAdded(HTMLDocument* doc, const AtomicString& name)
 {
     windowProxy(DOMWrapperWorld::mainWorld())->namedItemAdded(doc, name);
 }
 
 void ScriptController::namedItemRemoved(HTMLDocument* doc, const AtomicString& name)
 {
     windowProxy(DOMWrapperWorld::mainWorld())->namedItemRemoved(doc, name);
 }
 
 static bool isInPrivateScriptIsolateWorld(v8::Isolate* isolate)
 {
     v8::Handle<v8::Context> context = isolate->GetCurrentContext();
     return !context.IsEmpty() && toDOMWindow(context) && DOMWrapperWorld::current(isolate).isPrivateScriptIsolatedWorld();
 }
 
 bool ScriptController::canExecuteScripts(ReasonForCallingCanExecuteScripts reason)
 {
     // For performance reasons, we check isInPrivateScriptIsolateWorld() only if
     // canExecuteScripts is going to return false.
 
-    if (m_frame->document() && m_frame->document()->isSandboxed(SandboxScripts)) {
-        if (isInPrivateScriptIsolateWorld(m_isolate))
+    if (frame()->document() && frame()->document()->isSandboxed(SandboxScripts)) {
+        if (isInPrivateScriptIsolateWorld(isolate()))
             return true;
         // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists.
         if (reason == AboutToExecuteScript)
-            m_frame->document()->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Blocked script execution in '" + m_frame->document()->url().elidedString() + "' because the document's frame is sandboxed and the 'allow-scripts' permission is not set."));
+            frame()->document()->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Blocked script execution in '" + frame()->document()->url().elidedString() + "' because the document's frame is sandboxed and the 'allow-scripts' permission is not set."));
         return false;
     }
 
-    if (m_frame->document() && m_frame->document()->isViewSource()) {
-        ASSERT(m_frame->document()->securityOrigin()->isUnique());
+    if (frame()->document() && frame()->document()->isViewSource()) {
+        ASSERT(frame()->document()->securityOrigin()->isUnique());
         return true;
     }
 
-    FrameLoaderClient* client = m_frame->loader().client();
+    FrameLoaderClient* client = frame()->loader().client();
     if (!client)
         return false;
-    Settings* settings = m_frame->settings();
+    Settings* settings = frame()->settings();
     const bool allowed = client->allowScript(settings && settings->scriptEnabled())
-        || isInPrivateScriptIsolateWorld(m_isolate);
+        || isInPrivateScriptIsolateWorld(isolate());
     if (!allowed && reason == AboutToExecuteScript)
         client->didNotAllowScript();
     return allowed;
 }
 
 bool ScriptController::executeScriptIfJavaScriptURL(const KURL& url)
 {
     if (!protocolIsJavaScript(url))
         return false;
 
-    bool shouldBypassMainWorldContentSecurityPolicy = ContentSecurityPolicy::shouldBypassMainWorld(m_frame->document());
-    if (!m_frame->page()
-        || (!shouldBypassMainWorldContentSecurityPolicy && !m_frame->document()->contentSecurityPolicy()->allowJavaScriptURLs(m_frame->document()->url(), eventHandlerPosition().m_line)))
+    bool shouldBypassMainWorldContentSecurityPolicy = ContentSecurityPolicy::shouldBypassMainWorld(frame()->document());
+    if (!frame()->page()
+        || (!shouldBypassMainWorldContentSecurityPolicy && !frame()->document()->contentSecurityPolicy()->allowJavaScriptURLs(frame()->document()->url(), eventHandlerPosition().m_line)))
         return true;
 
-    if (m_frame->loader().stateMachine()->isDisplayingInitialEmptyDocument())
-        m_frame->loader().progress().progressStarted();
+    if (frame()->loader().stateMachine()->isDisplayingInitialEmptyDocument())
+        frame()->loader().progress().progressStarted();
 
     // We need to hold onto the LocalFrame here because executing script can
     // destroy the frame.
-    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
-    RefPtrWillBeRawPtr<Document> ownerDocument(m_frame->document());
+    RefPtrWillBeRawPtr<LocalFrame> protect(frame());
+    RefPtrWillBeRawPtr<Document> ownerDocument(frame()->document());
 
     const int javascriptSchemeLength = sizeof("javascript:") - 1;
 
-    bool locationChangeBefore = m_frame->navigationScheduler().locationChangePending();
+    bool locationChangeBefore = frame()->navigationScheduler().locationChangePending();
 
     String decodedURL = decodeURLEscapeSequences(url.string());
-    v8::HandleScope handleScope(m_isolate);
+    v8::HandleScope handleScope(isolate());
     v8::Local<v8::Value> result = evaluateScriptInMainWorld(ScriptSourceCode(decodedURL.substring(javascriptSchemeLength)), NotSharableCrossOrigin, DoNotExecuteScriptWhenScriptsDisabled);
 
     // If executing script caused this frame to be removed from the page, we
     // don't want to try to replace its document!
-    if (!m_frame->page())
+    if (!frame()->page())
         return true;
 
     if (result.IsEmpty() || !result->IsString())
         return true;
     String scriptResult = toCoreString(v8::Handle<v8::String>::Cast(result));
 
     // We're still in a frame, so there should be a DocumentLoader.
-    ASSERT(m_frame->document()->loader());
-    if (!locationChangeBefore && m_frame->navigationScheduler().locationChangePending())
+    ASSERT(frame()->document()->loader());
+    if (!locationChangeBefore && frame()->navigationScheduler().locationChangePending())
         return true;
 
-    m_frame->loader().replaceDocumentWhileExecutingJavaScriptURL(scriptResult, ownerDocument.get());
+    frame()->loader().replaceDocumentWhileExecutingJavaScriptURL(scriptResult, ownerDocument.get());
     return true;
 }
 
 void ScriptController::executeScriptInMainWorld(const String& script, ExecuteScriptPolicy policy)
 {
-    v8::HandleScope handleScope(m_isolate);
+    v8::HandleScope handleScope(isolate());
     evaluateScriptInMainWorld(ScriptSourceCode(script), NotSharableCrossOrigin, policy);
 }
 
 void ScriptController::executeScriptInMainWorld(const ScriptSourceCode& sourceCode, AccessControlStatus corsStatus, double* compilationFinishTime)
 {
-    v8::HandleScope handleScope(m_isolate);
+    v8::HandleScope handleScope(isolate());
     evaluateScriptInMainWorld(sourceCode, corsStatus, DoNotExecuteScriptWhenScriptsDisabled, compilationFinishTime);
 }
 
 v8::Local<v8::Value> ScriptController::executeScriptInMainWorldAndReturnValue(const ScriptSourceCode& sourceCode)
 {
     return evaluateScriptInMainWorld(sourceCode, NotSharableCrossOrigin, DoNotExecuteScriptWhenScriptsDisabled);
 }
 
 v8::Local<v8::Value> ScriptController::evaluateScriptInMainWorld(const ScriptSourceCode& sourceCode, AccessControlStatus corsStatus, ExecuteScriptPolicy policy, double* compilationFinishTime)
 {
     if (policy == DoNotExecuteScriptWhenScriptsDisabled && !canExecuteScripts(AboutToExecuteScript))
         return v8::Local<v8::Value>();
 
     String sourceURL = sourceCode.url();
     const String* savedSourceURL = m_sourceURL;
     m_sourceURL = &sourceURL;
 
-    v8::EscapableHandleScope handleScope(m_isolate);
-    v8::Handle<v8::Context> context = toV8Context(m_frame, DOMWrapperWorld::mainWorld());
+    v8::EscapableHandleScope handleScope(isolate());
+    v8::Handle<v8::Context> context = toV8Context(frame(), DOMWrapperWorld::mainWorld());
     if (context.IsEmpty())
         return v8::Local<v8::Value>();
 
     ScriptState* scriptState = ScriptState::from(context);
     ScriptState::Scope scope(scriptState);
 
-    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
-    if (m_frame->loader().stateMachine()->isDisplayingInitialEmptyDocument())
-        m_frame->loader().didAccessInitialDocument();
+    RefPtrWillBeRawPtr<LocalFrame> protect(frame());
+    if (frame()->loader().stateMachine()->isDisplayingInitialEmptyDocument())
+        frame()->loader().didAccessInitialDocument();
 
-    OwnPtr<ScriptSourceCode> maybeProcessedSourceCode =  InspectorInstrumentation::preprocess(m_frame, sourceCode);
+    OwnPtr<ScriptSourceCode> maybeProcessedSourceCode =  InspectorInstrumentation::preprocess(frame(), sourceCode);
     const ScriptSourceCode& sourceCodeToCompile = maybeProcessedSourceCode ? *maybeProcessedSourceCode : sourceCode;
 
     v8::Local<v8::Value> object = executeScriptAndReturnValue(scriptState->context(), sourceCodeToCompile, corsStatus, compilationFinishTime);
     m_sourceURL = savedSourceURL;
 
     if (object.IsEmpty())
         return v8::Local<v8::Value>();
 
     return handleScope.Escape(object);
 }
 
 void ScriptController::executeScriptInIsolatedWorld(int worldID, const Vector<ScriptSourceCode>& sources, int extensionGroup, Vector<v8::Local<v8::Value> >* results)
 {
     ASSERT(worldID > 0);
 
-    RefPtr<DOMWrapperWorld> world = DOMWrapperWorld::ensureIsolatedWorld(m_isolate, worldID, extensionGroup);
+    RefPtr<DOMWrapperWorld> world = DOMWrapperWorld::ensureIsolatedWorld(isolate(), worldID, extensionGroup);
     WindowProxy* isolatedWorldWindowProxy = windowProxy(*world);
     if (!isolatedWorldWindowProxy->isContextInitialized())
         return;
 
     ScriptState* scriptState = isolatedWorldWindowProxy->scriptState();
     v8::Context::Scope scope(scriptState->context());
-    v8::Local<v8::Array> resultArray = v8::Array::New(m_isolate, sources.size());
+    v8::Local<v8::Array> resultArray = v8::Array::New(isolate(), sources.size());
 
     for (size_t i = 0; i < sources.size(); ++i) {
         v8::Local<v8::Value> evaluationResult = executeScriptAndReturnValue(scriptState->context(), sources[i]);
         if (evaluationResult.IsEmpty())
-            evaluationResult = v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
+            evaluationResult = v8::Local<v8::Value>::New(isolate(), v8::Undefined(isolate()));
         resultArray->Set(i, evaluationResult);
     }
 
     if (results) {
         for (size_t i = 0; i < resultArray->Length(); ++i)
             results->append(resultArray->Get(i));
     }
 }
 
 } // namespace blink