bool Dictionary::getOwnPropertiesAsStringHashMap(HashMap<String, String>& hashMap) const
{
if (!isObject())
return false;
v8::Handle<v8::Object> options = m_options->ToObject();
if (options.IsEmpty())
return false;
v8::Local<v8::Array> properties = options->GetOwnPropertyNames();
if (properties.IsEmpty())
return true;
for (uint32_t i = 0; i < properties->Length(); ++i) {
v8::Local<v8::String> key = properties->Get(i)->ToString();
if (!options->Has(key))
continue;
v8::Local<v8::Value> value = options->Get(key);
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringKey, key, false);
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, value, false);
if (!static_cast<const String&>(stringKey).isEmpty())
hashMap.set(stringKey, stringValue);
}
return true;
}
v8::Local<v8::Value> V8WorkerGlobalScopeEventListener::callListenerFunction(ExecutionContext* context, v8::Handle<v8::Value> jsEvent, Event* event)
{
v8::Local<v8::Function> handlerFunction = getListenerFunction(context);
v8::Local<v8::Object> receiver = getReceiverObject(context, event);
if (handlerFunction.IsEmpty() || receiver.IsEmpty())
return v8::Local<v8::Value>();
InspectorInstrumentationCookie cookie;
if (InspectorInstrumentation::timelineAgentEnabled(context)) {
String resourceName("undefined");
int lineNumber = 1;
v8::Handle<v8::Function> originalFunction = getBoundFunction(handlerFunction);
v8::ScriptOrigin origin = originalFunction->GetScriptOrigin();
if (!origin.ResourceName().IsEmpty()) {
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringResourceName, origin.ResourceName(), v8::Local<v8::Value>());
resourceName = stringResourceName;
lineNumber = originalFunction->GetScriptLineNumber() + 1;
}
cookie = InspectorInstrumentation::willCallFunction(context, resourceName, lineNumber);
}
v8::Isolate* isolate = toIsolate(context);
v8::Handle<v8::Value> parameters[1] = { jsEvent };
v8::Local<v8::Value> result = V8ScriptRunner::callFunction(handlerFunction, context, receiver, WTF_ARRAY_LENGTH(parameters), parameters, isolate);
InspectorInstrumentation::didCallFunction(cookie);
return result;
}
// Concatenates "args" to a string. If args is empty, returns empty string.
// Firefox/Safari/IE support non-standard arguments to document.write, ex:
// document.write("a", "b", "c") --> document.write("abc")
// document.write() --> document.write("")
static String writeHelperGetString(const v8::FunctionCallbackInfo<v8::Value>& args)
{
StringBuilder builder;
for (int i = 0; i < args.Length(); ++i) {
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringArgument, args[i], String());
builder.append(stringArgument);
}
return builder.toString();
}
inline bool Dictionary::getStringType(const String& key, StringType& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, v8Value, false);
value = stringValue;
return true;
}
bool Dictionary::getWithUndefinedOrNullCheck(const String& key, String& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value) || WebCore::isUndefinedOrNull(v8Value))
return false;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, v8Value, false);
value = stringValue;
return true;
}
static bool populateContextMenuItems(v8::Local<v8::Array>& itemArray, ContextMenu& menu, v8::Isolate* isolate)
{
for (size_t i = 0; i < itemArray->Length(); ++i) {
v8::Local<v8::Object> item = v8::Local<v8::Object>::Cast(itemArray->Get(i));
v8::Local<v8::Value> type = item->Get(v8AtomicString(isolate, "type"));
v8::Local<v8::Value> id = item->Get(v8AtomicString(isolate, "id"));
v8::Local<v8::Value> label = item->Get(v8AtomicString(isolate, "label"));
v8::Local<v8::Value> enabled = item->Get(v8AtomicString(isolate, "enabled"));
v8::Local<v8::Value> checked = item->Get(v8AtomicString(isolate, "checked"));
v8::Local<v8::Value> subItems = item->Get(v8AtomicString(isolate, "subItems"));
if (!type->IsString())
continue;
String typeString = toCoreStringWithNullCheck(type.As<v8::String>());
if (typeString == "separator") {
ContextMenuItem item(ContextMenuItem(SeparatorType,
ContextMenuItemCustomTagNoAction,
String()));
menu.appendItem(item);
} else if (typeString == "subMenu" && subItems->IsArray()) {
ContextMenu subMenu;
v8::Local<v8::Array> subItemsArray = v8::Local<v8::Array>::Cast(subItems);
if (!populateContextMenuItems(subItemsArray, subMenu, isolate))
return false;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, labelString, label, false);
ContextMenuItem item(SubmenuType,
ContextMenuItemCustomTagNoAction,
labelString,
&subMenu);
menu.appendItem(item);
} else {
ContextMenuAction typedId = static_cast<ContextMenuAction>(ContextMenuItemBaseCustomTag + id->ToInt32()->Value());
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, labelString, label, false);
ContextMenuItem menuItem((typeString == "checkbox" ? CheckableActionType : ActionType), typedId, labelString);
if (checked->IsBoolean())
menuItem.setChecked(checked->ToBoolean()->Value());
if (enabled->IsBoolean())
menuItem.setEnabled(enabled->ToBoolean()->Value());
menu.appendItem(menuItem);
}
}
return true;
}
static PassRefPtr<JSONValue> v8ToJSONValue(v8::Handle<v8::Value> value, int maxDepth, v8::Isolate* isolate)
{
if (value.IsEmpty()) {
ASSERT_NOT_REACHED();
return 0;
}
if (!maxDepth)
return 0;
maxDepth--;
if (value->IsNull() || value->IsUndefined())
return JSONValue::null();
if (value->IsBoolean())
return JSONBasicValue::create(value->BooleanValue());
if (value->IsNumber())
return JSONBasicValue::create(value->NumberValue());
if (value->IsString())
return JSONString::create(toCoreString(value.As<v8::String>()));
if (value->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
RefPtr<JSONArray> inspectorArray = JSONArray::create();
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; i++) {
v8::Local<v8::Value> value = array->Get(v8::Int32::New(isolate, i));
RefPtr<JSONValue> element = v8ToJSONValue(value, maxDepth, isolate);
if (!element)
return 0;
inspectorArray->pushValue(element);
}
return inspectorArray;
}
if (value->IsObject()) {
RefPtr<JSONObject> jsonObject = JSONObject::create();
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
v8::Local<v8::Array> propertyNames = object->GetPropertyNames();
uint32_t length = propertyNames->Length();
for (uint32_t i = 0; i < length; i++) {
v8::Local<v8::Value> name = propertyNames->Get(v8::Int32::New(isolate, i));
// FIXME(yurys): v8::Object should support GetOwnPropertyNames
if (name->IsString() && !object->HasRealNamedProperty(v8::Handle<v8::String>::Cast(name)))
continue;
RefPtr<JSONValue> propertyValue = v8ToJSONValue(object->Get(name), maxDepth, isolate);
if (!propertyValue)
return 0;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, nameString, name, 0);
jsonObject->setValue(nameString, propertyValue);
}
return jsonObject;
}
ASSERT_NOT_REACHED();
return 0;
}
bool Dictionary::convert(ConversionContext& context, const String& key, String& value) const
{
ConversionContextScope scope(context);
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return true;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, v8Value, false);
value = stringValue;
return true;
}
static bool resourceInfo(const v8::Handle<v8::Function> function, String& resourceName, int& lineNumber)
{
v8::ScriptOrigin origin = function->GetScriptOrigin();
if (origin.ResourceName().IsEmpty()) {
resourceName = "undefined";
lineNumber = 1;
} else {
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringResourceName, origin.ResourceName(), false);
resourceName = stringResourceName;
lineNumber = function->GetScriptLineNumber() + 1;
}
return true;
}
static v8::Handle<v8::Value> getItem(HTMLAllCollection* collection, v8::Handle<v8::Value> argument, const CallbackInfo& info)
{
v8::Local<v8::Uint32> index = argument->ToArrayIndex();
if (index.IsEmpty()) {
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, name, argument, v8::Undefined(info.GetIsolate()));
v8::Handle<v8::Value> result = getNamedItems(collection, name, info);
if (result.IsEmpty())
return v8::Undefined(info.GetIsolate());
return result;
}
RefPtr<Element> result = collection->item(index->Uint32Value());
return toV8(result.release(), info.Holder(), info.GetIsolate());
}
ScriptValue WorkerScriptController::evaluate(const String& script, const String& fileName, const TextPosition& scriptStartPosition, WorkerGlobalScopeExecutionState* state)
{
v8::HandleScope handleScope(isolate());
if (!initializeContextIfNeeded())
return ScriptValue();
v8::Handle<v8::Context> context = m_contextHolder->context();
if (!m_disableEvalPending.isEmpty()) {
context->AllowCodeGenerationFromStrings(false);
context->SetErrorMessageForCodeGenerationFromStrings(v8String(isolate(), m_disableEvalPending));
m_disableEvalPending = String();
}
v8::Context::Scope scope(context);
v8::TryCatch block;
v8::Handle<v8::String> scriptString = v8String(isolate(), script);
v8::Handle<v8::Script> compiledScript = V8ScriptRunner::compileScript(scriptString, fileName, scriptStartPosition, 0, isolate());
v8::Local<v8::Value> result = V8ScriptRunner::runCompiledScript(compiledScript, &m_workerGlobalScope, isolate());
if (!block.CanContinue()) {
m_workerGlobalScope.script()->forbidExecution();
return ScriptValue();
}
if (block.HasCaught()) {
v8::Local<v8::Message> message = block.Message();
state->hadException = true;
state->errorMessage = toCoreString(message->Get());
state->lineNumber = message->GetLineNumber();
state->columnNumber = message->GetStartColumn() + 1;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, sourceURL, message->GetScriptResourceName(), ScriptValue());
state->sourceURL = sourceURL;
state->exception = ScriptValue(block.Exception(), isolate());
block.Reset();
} else
state->hadException = false;
if (result.IsEmpty() || result->IsUndefined())
return ScriptValue();
return ScriptValue(result, isolate());
}
bool Dictionary::get(const String& key, Vector<String>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
if (!v8Value->IsArray())
return false;
v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
for (size_t i = 0; i < v8Array->Length(); ++i) {
v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Uint32::New(m_isolate, i));
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, indexedValue, false);
value.append(stringValue);
}
return true;
}
String eventListenerHandlerBody(Document* document, EventListener* listener)
{
if (listener->type() != EventListener::JSEventListenerType)
return "";
v8::HandleScope scope(toIsolate(document));
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener);
v8::Handle<v8::Context> context = toV8Context(document, v8Listener->world());
v8::Context::Scope contextScope(context);
v8::Handle<v8::Object> object = v8Listener->getListenerObject(document);
if (object.IsEmpty())
return "";
v8::Handle<v8::Function> function = eventListenerEffectiveFunction(scope.GetIsolate(), object);
if (function.IsEmpty())
return "";
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, functionString, function, "");
return functionString;
}
PassRefPtr<DOMStringList> toDOMStringList(v8::Handle<v8::Value> value, v8::Isolate* isolate)
{
v8::Local<v8::Value> v8Value(v8::Local<v8::Value>::New(isolate, value));
if (V8DOMStringList::HasInstance(v8Value, isolate, worldType(isolate))) {
RefPtr<DOMStringList> ret = V8DOMStringList::toNative(v8::Handle<v8::Object>::Cast(v8Value));
return ret.release();
}
if (!v8Value->IsArray())
return 0;
RefPtr<DOMStringList> ret = DOMStringList::create();
v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
for (size_t i = 0; i < v8Array->Length(); ++i) {
v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Integer::New(i, isolate));
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, indexedValue, 0);
ret->append(stringValue);
}
return ret.release();
}
bool Dictionary::get(const String& key, HashSet<AtomicString>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
// FIXME: Support array-like objects
if (!v8Value->IsArray())
return false;
ASSERT(m_isolate);
ASSERT(m_isolate == v8::Isolate::GetCurrent());
v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
for (size_t i = 0; i < v8Array->Length(); ++i) {
v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Integer::New(m_isolate, i));
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, indexedValue, false);
value.add(stringValue);
}
return true;
}
bool Dictionary::getOwnPropertyNames(Vector<String>& names) const
{
if (!isObject())
return false;
v8::Handle<v8::Object> options = m_options->ToObject();
if (options.IsEmpty())
return false;
v8::Local<v8::Array> properties = options->GetOwnPropertyNames();
if (properties.IsEmpty())
return true;
for (uint32_t i = 0; i < properties->Length(); ++i) {
v8::Local<v8::String> key = properties->Get(i)->ToString();
if (!options->Has(key))
continue;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringKey, key, false);
names.append(stringKey);
}
return true;
}
AtomicString V8CustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
{
v8::Handle<v8::Function> lookupNamespaceURIFunc;
v8::Handle<v8::String> lookupNamespaceURIName = v8AtomicString(m_isolate, "lookupNamespaceURI");
// Check if the resolver has a function property named lookupNamespaceURI.
if (m_resolver->Has(lookupNamespaceURIName)) {
v8::Handle<v8::Value> lookupNamespaceURI = m_resolver->Get(lookupNamespaceURIName);
if (lookupNamespaceURI->IsFunction())
lookupNamespaceURIFunc = v8::Handle<v8::Function>::Cast(lookupNamespaceURI);
}
if (lookupNamespaceURIFunc.IsEmpty() && !m_resolver->IsFunction()) {
LocalFrame* frame = callingDOMWindow(m_isolate)->frame();
if (frame && frame->host())
frame->host()->console().addMessage(JSMessageSource, ErrorMessageLevel, "XPathNSResolver does not have a lookupNamespaceURI method.");
return nullAtom;
}
// Catch exceptions from calling the namespace resolver.
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true); // Print exceptions to console.
const int argc = 1;
v8::Handle<v8::Value> argv[argc] = { v8String(m_isolate, prefix) };
v8::Handle<v8::Function> function = lookupNamespaceURIFunc.IsEmpty() ? v8::Handle<v8::Function>::Cast(m_resolver) : lookupNamespaceURIFunc;
v8::Handle<v8::Value> retval = ScriptController::callFunction(callingExecutionContext(m_isolate), function, m_resolver, argc, argv, m_isolate);
// Eat exceptions from namespace resolver and return an empty string. This will most likely cause NamespaceError.
if (tryCatch.HasCaught())
return nullAtom;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, returnString, retval, nullAtom);
return returnString;
}
