bool ParsedProperties::parseBlobPropertyBag(v8::Local<v8::Value> propertyBag, const char* blobClassName, v8::Isolate* isolate)
{
ASSERT(m_endings == "transparent");
V8TRYCATCH_RETURN(Dictionary, dictionary, Dictionary(propertyBag, isolate), false);
V8TRYCATCH_RETURN(bool, containsEndings, dictionary.get("endings", m_endings), false);
if (containsEndings) {
if (m_endings != "transparent" && m_endings != "native") {
throwTypeError(ExceptionMessages::failedToConstruct(blobClassName, "The \"endings\" property must be either \"transparent\" or \"native\"."), isolate);
return false;
}
}
V8TRYCATCH_RETURN(bool, containsType, dictionary.get("type", m_contentType), false);
if (containsType) {
if (!m_contentType.containsOnlyASCII()) {
throwError(v8SyntaxError, ExceptionMessages::failedToConstruct(blobClassName, "The \"type\" property must consist of ASCII characters."), isolate);
return false;
}
m_contentType = m_contentType.lower();
}
if (!m_hasFileProperties)
return true;
v8::Local<v8::Value> lastModified;
V8TRYCATCH_RETURN(bool, containsLastModified, dictionary.get("lastModified", lastModified), false);
if (containsLastModified) {
V8TRYCATCH_RETURN(long long, lastModifiedInt, toInt64(lastModified), false);
setLastModified(static_cast<double>(lastModifiedInt) / msPerSecond);
} else {
bool Dictionary::get(const String& key, unsigned long long& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
V8TRYCATCH_RETURN(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false);
if (v8Number.IsEmpty())
return false;
double d = v8Number->Value();
doubleToInteger(d, value);
return true;
}
bool Dictionary::get(const String& key, double& value, bool& hasValue) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value)) {
hasValue = false;
return false;
}
hasValue = true;
V8TRYCATCH_RETURN(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false);
if (v8Number.IsEmpty())
return false;
value = v8Number->Value();
return true;
}
uint32_t toUInt32(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
{
// Fast case. The value is already a 32-bit unsigned integer.
if (value->IsUint32())
return value->Uint32Value();
// Fast case. The value is a 32-bit signed integer - possibly positive?
if (value->IsInt32()) {
int32_t result = value->Int32Value();
if (result >= 0)
return result;
if (configuration == EnforceRange) {
exceptionState.throwTypeError("Value is outside the 'unsigned long' value range.");
return 0;
}
return result;
}
// Can the value be converted to a number?
V8TRYCATCH_EXCEPTION_RETURN(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
if (numberObject.IsEmpty()) {
exceptionState.throwTypeError("Not convertible to a number value (of type 'unsigned long'.)");
return 0;
}
if (configuration == EnforceRange)
return enforceRange(numberObject->Value(), 0, kMaxUInt32, "unsigned long", exceptionState);
// Does the value convert to nan or to an infinity?
double numberValue = numberObject->Value();
if (std::isnan(numberValue) || std::isinf(numberValue))
return 0;
if (configuration == Clamp)
return clampTo<uint32_t>(numberObject->Value());
V8TRYCATCH_RETURN(uint32_t, result, numberObject->Uint32Value(), 0);
return result;
}
