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; }