V8LazyEventListener.cpp [plain text]
#include "config.h"
#include "V8LazyEventListener.h"
#include "ContentSecurityPolicy.h"
#include "Document.h"
#include "Frame.h"
#include "HTMLElement.h"
#include "HTMLFormElement.h"
#include "Node.h"
#include "V8Binding.h"
#include "V8DOMWrapper.h"
#include "V8Document.h"
#include "V8HTMLFormElement.h"
#include "V8HiddenPropertyName.h"
#include "V8Node.h"
#include "V8Proxy.h"
#include "V8RecursionScope.h"
#include "WorldContextHandle.h"
#include <wtf/StdLibExtras.h>
namespace WebCore {
V8LazyEventListener::V8LazyEventListener(const AtomicString& functionName, const AtomicString& eventParameterName, const String& code, const String sourceURL, const TextPosition& position, Node* node, const WorldContextHandle& worldContext)
: V8AbstractEventListener(true, worldContext)
, m_functionName(functionName)
, m_eventParameterName(eventParameterName)
, m_code(code)
, m_sourceURL(sourceURL)
, m_node(node)
, m_position(position)
{
}
template<typename T>
v8::Handle<v8::Object> toObjectWrapper(T* domObject)
{
if (!domObject)
return v8::Object::New();
v8::Handle<v8::Value> value = toV8(domObject);
if (value.IsEmpty())
return v8::Object::New();
return value.As<v8::Object>();
}
v8::Local<v8::Value> V8LazyEventListener::callListenerFunction(ScriptExecutionContext* context, v8::Handle<v8::Value> jsEvent, Event* event)
{
v8::Local<v8::Object> listenerObject = getListenerObject(context);
if (listenerObject.IsEmpty())
return v8::Local<v8::Value>();
v8::Local<v8::Function> handlerFunction = listenerObject.As<v8::Function>();
v8::Local<v8::Object> receiver = getReceiverObject(event);
if (handlerFunction.IsEmpty() || receiver.IsEmpty())
return v8::Local<v8::Value>();
v8::Handle<v8::Value> parameters[1] = { jsEvent };
if (V8Proxy* proxy = V8Proxy::retrieve(context)) {
Frame* frame = static_cast<Document*>(context)->frame();
if (frame->script()->canExecuteScripts(AboutToExecuteScript))
return proxy->callFunction(handlerFunction, receiver, 1, parameters);
}
return v8::Local<v8::Value>();
}
static v8::Handle<v8::Value> V8LazyEventListenerToString(const v8::Arguments& args)
{
return args.Holder()->GetHiddenValue(V8HiddenPropertyName::toStringString());
}
void V8LazyEventListener::prepareListenerObject(ScriptExecutionContext* context)
{
if (hasExistingListenerObject())
return;
if (context->isDocument() && !static_cast<Document*>(context)->contentSecurityPolicy()->allowInlineEventHandlers())
return;
v8::HandleScope handleScope;
V8Proxy* proxy = V8Proxy::retrieve(context);
if (!proxy)
return;
ASSERT(context->isDocument());
if (!static_cast<Document*>(context)->frame()->script()->canExecuteScripts(NotAboutToExecuteScript))
return;
v8::Local<v8::Context> v8Context = worldContext().adjustedContext(proxy);
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
String code = "(function() {" \
"with (arguments[2]) {" \
"with (arguments[1]) {" \
"with (arguments[0]) {";
code.append("return function(");
code.append(m_eventParameterName);
code.append(") {");
code.append(m_code);
code.append("\n};}}}})");
v8::Handle<v8::String> codeExternalString = v8ExternalString(code);
v8::Handle<v8::Script> script = V8Proxy::compileScript(codeExternalString, m_sourceURL, m_position);
if (script.IsEmpty())
return;
v8::Local<v8::Value> value;
{
V8RecursionScope::MicrotaskSuppression scope;
value = script->Run();
}
if (value.IsEmpty())
return;
ASSERT(value->IsFunction());
v8::Local<v8::Function> intermediateFunction = value.As<v8::Function>();
HTMLFormElement* formElement = 0;
if (m_node && m_node->isHTMLElement())
formElement = static_cast<HTMLElement*>(m_node)->form();
v8::Handle<v8::Object> nodeWrapper = toObjectWrapper<Node>(m_node);
v8::Handle<v8::Object> formWrapper = toObjectWrapper<HTMLFormElement>(formElement);
v8::Handle<v8::Object> documentWrapper = toObjectWrapper<Document>(m_node ? m_node->ownerDocument() : 0);
v8::Handle<v8::Value> parameters[3] = { nodeWrapper, formWrapper, documentWrapper };
v8::Local<v8::Value> innerValue;
{
V8RecursionScope::MicrotaskSuppression scope;
innerValue = intermediateFunction->Call(v8Context->Global(), 3, parameters);
}
if (innerValue.IsEmpty() || !innerValue->IsFunction())
return;
v8::Local<v8::Function> wrappedFunction = innerValue.As<v8::Function>();
v8::Persistent<v8::FunctionTemplate>& toStringTemplate =
V8BindingPerIsolateData::current()->lazyEventListenerToStringTemplate();
if (toStringTemplate.IsEmpty())
toStringTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New(V8LazyEventListenerToString));
v8::Local<v8::Function> toStringFunction;
if (!toStringTemplate.IsEmpty())
toStringFunction = toStringTemplate->GetFunction();
if (!toStringFunction.IsEmpty()) {
String toStringResult = "function ";
toStringResult.append(m_functionName);
toStringResult.append("(");
toStringResult.append(m_eventParameterName);
toStringResult.append(") {\n ");
toStringResult.append(m_code);
toStringResult.append("\n}");
wrappedFunction->SetHiddenValue(V8HiddenPropertyName::toStringString(), v8ExternalString(toStringResult));
wrappedFunction->Set(v8::String::NewSymbol("toString"), toStringFunction);
}
wrappedFunction->SetName(v8::String::New(fromWebCoreString(m_functionName), m_functionName.length()));
setListenerObject(wrappedFunction);
}
}