v8::Handle<v8::Value> V8DatabaseSync::changeVersionCallback(const v8::Arguments& args)
{
INC_STATS("DOM.DatabaseSync.changeVersion()");
if (args.Length() < 2)
return throwError(SYNTAX_ERR);
EXCEPTION_BLOCK(String, oldVersion, toWebCoreString(args[0]));
EXCEPTION_BLOCK(String, newVersion, toWebCoreString(args[1]));
DatabaseSync* database = V8DatabaseSync::toNative(args.Holder());
RefPtr<V8SQLTransactionSyncCallback> callback;
if (args.Length() > 2) {
if (!args[2]->IsObject())
return throwError(TYPE_MISMATCH_ERR);
callback = V8SQLTransactionSyncCallback::create(args[2]);
}
ExceptionCode ec = 0;
database->changeVersion(oldVersion, newVersion, callback.release(), ec);
V8Proxy::setDOMException(ec);
return v8::Undefined();
}
v8::Handle<v8::Value> V8TestEventConstructor::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestEventConstructor.Constructor");
if (!args.IsConstructCall())
return throwError("DOM object constructor cannot be called as a function.", V8Proxy::TypeError);
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
if (args.Length() < 1)
return throwError("Not enough arguments", V8Proxy::TypeError);
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, type, args[0]);
TestEventConstructorInit eventInit;
if (args.Length() >= 2) {
EXCEPTION_BLOCK(Dictionary, options, args[1]);
if (!fillTestEventConstructorInit(eventInit, options))
return v8::Undefined();
}
RefPtr<TestEventConstructor> event = TestEventConstructor::create(type, eventInit);
V8DOMWrapper::setDOMWrapper(args.Holder(), &info, event.get());
return toV8(event.release(), args.Holder());
}
static v8::Handle<v8::Value> methodCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestMediaQueryListListener.method");
if (args.Length() < 1)
return V8Proxy::throwNotEnoughArgumentsError();
TestMediaQueryListListener* imp = V8TestMediaQueryListListener::toNative(args.Holder());
EXCEPTION_BLOCK(RefPtr<MediaQueryListListener>, listener, MediaQueryListListener::create(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
imp->method(listener);
return v8::Handle<v8::Value>();
}
static v8::Handle<v8::Value> setOrientToAngleCallback(const v8::Arguments& args)
{
INC_STATS("DOM.SVGMarkerElement.setOrientToAngle");
SVGMarkerElement* imp = V8SVGMarkerElement::toNative(args.Holder());
EXCEPTION_BLOCK(RefPtr<SVGPropertyTearOff<SVGAngle> >, angle, V8SVGAngle::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined)) ? V8SVGAngle::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined))) : 0);
if (!angle) {
V8Proxy::setDOMException(WebCore::TYPE_MISMATCH_ERR);
return v8::Handle<v8::Value>();
}
imp->setOrientToAngle(angle->propertyReference());
return v8::Handle<v8::Value>();
}
void AppLayer::_OnReceive(const apl::byte_t* apBuffer, size_t aSize)
{
if(!this->IsLowerLayerUp())
throw InvalidStateException(LOCATION, "LowerLaterDown");
try {
mIncoming.Write(apBuffer, aSize);
mIncoming.Interpret();
LOG_BLOCK(LEV_INTERPRET, "<= AL " << mIncoming.ToString());
FunctionCodes func = mIncoming.GetFunction();
AppControlField ctrl = mIncoming.GetControl();
switch(func){
case(FC_CONFIRM):
this->OnConfirm(ctrl, mIncoming);
break;
case(FC_RESPONSE):
this->OnResponse(ctrl, mIncoming);
break;
case(FC_UNSOLICITED_RESPONSE):
this->OnUnsolResponse(ctrl, mIncoming);
break;
default: //otherwise, assume it's a request
this->OnRequest(ctrl, mIncoming);
break;
}
}
catch(ObjectException oex)
{
EXCEPTION_BLOCK(LEV_WARNING, oex);
this->OnUnknownObject(mIncoming.GetFunction(), mIncoming.GetControl());
}
catch(Exception ex) {
EXCEPTION_BLOCK(LEV_WARNING, ex);
}
}
static v8::Handle<v8::Value> initializeCallback(const v8::Arguments& args)
{
INC_STATS("DOM.SVGLengthList.initialize");
if (args.Length() < 1)
return throwError("Not enough arguments", V8Proxy::TypeError);
RefPtr<SVGListPropertyTearOff<SVGLengthList> > imp = V8SVGLengthList::toNative(args.Holder());
ExceptionCode ec = 0;
{
if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8SVGLength::HasInstance(args[0])) {
V8Proxy::throwTypeError();
return notHandledByInterceptor();
}
EXCEPTION_BLOCK(RefPtr<SVGPropertyTearOff<SVGLength> >, item, V8SVGLength::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined)) ? V8SVGLength::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined))) : 0);
RefPtr<SVGPropertyTearOff<SVGLength> > result = imp->initialize(item, ec);
if (UNLIKELY(ec))
goto fail;
return toV8(result.release());
}
fail:
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
static v8::Handle<v8::Value> multiplyCallback(const v8::Arguments& args)
{
INC_STATS("DOM.SVGMatrix.multiply");
if (args.Length() < 1)
return throwError("Not enough arguments", V8Proxy::TypeError);
RefPtr<SVGPropertyTearOff<SVGMatrix> > wrapper = V8SVGMatrix::toNative(args.Holder());
if (wrapper->role() == AnimValRole) {
V8Proxy::setDOMException(NO_MODIFICATION_ALLOWED_ERR);
return v8::Handle<v8::Value>();
}
SVGMatrix& impInstance = wrapper->propertyReference();
SVGMatrix* imp = &impInstance;
if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8SVGMatrix::HasInstance(args[0])) {
V8Proxy::throwTypeError();
return notHandledByInterceptor();
}
EXCEPTION_BLOCK(RefPtr<SVGPropertyTearOff<SVGMatrix> >, secondMatrix, V8SVGMatrix::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined)) ? V8SVGMatrix::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined))) : 0);
if (!secondMatrix) {
V8Proxy::setDOMException(WebCore::TYPE_MISMATCH_ERR);
return v8::Handle<v8::Value>();
}
return toV8(WTF::getPtr(SVGPropertyTearOff<SVGMatrix>::create(imp->multiply(secondMatrix->propertyReference()))));
}
v8::Handle<v8::Value> V8Blob::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Blob.Constructor");
if (!args.IsConstructCall())
return V8Proxy::throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
// Get the script execution context.
ScriptExecutionContext* context = getScriptExecutionContext();
if (!context)
return V8Proxy::throwError(V8Proxy::ReferenceError, "Blob constructor associated document is unavailable", args.GetIsolate());
if (!args.Length()) {
RefPtr<Blob> blob = Blob::create();
return toV8(blob.get(), args.GetIsolate());
}
v8::Local<v8::Value> firstArg = args[0];
if (!firstArg->IsArray())
return V8Proxy::throwTypeError("First argument of the constructor is not of type Array", args.GetIsolate());
String type;
String endings = "transparent";
if (args.Length() > 1) {
if (!args[1]->IsObject())
return V8Proxy::throwTypeError("Second argument of the constructor is not of type Object", args.GetIsolate());
Dictionary dictionary(args[1]);
v8::TryCatch tryCatchEndings;
bool containsEndings = dictionary.get("endings", endings);
if (tryCatchEndings.HasCaught())
return throwError(tryCatchEndings.Exception(), args.GetIsolate());
if (containsEndings) {
if (endings != "transparent" && endings != "native")
return V8Proxy::throwTypeError("The endings property must be either \"transparent\" or \"native\"", args.GetIsolate());
}
v8::TryCatch tryCatchType;
dictionary.get("type", type);
if (tryCatchType.HasCaught())
return throwError(tryCatchType.Exception(), args.GetIsolate());
}
ASSERT(endings == "transparent" || endings == "native");
RefPtr<WebKitBlobBuilder> blobBuilder = WebKitBlobBuilder::create();
EXCEPTION_BLOCK(v8::Local<v8::Array>, blobParts, v8::Local<v8::Array>::Cast(firstArg));
uint32_t length = blobParts->Length();
for (uint32_t i = 0; i < length; ++i) {
v8::Local<v8::Value> item = blobParts->Get(v8::Uint32::New(i));
ASSERT(!item.IsEmpty());
#if ENABLE(BLOB)
if (V8ArrayBuffer::HasInstance(item)) {
ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(v8::Handle<v8::Object>::Cast(item));
ASSERT(arrayBuffer);
blobBuilder->append(arrayBuffer);
} else
#endif
if (V8Blob::HasInstance(item)) {
Blob* blob = V8Blob::toNative(v8::Handle<v8::Object>::Cast(item));
ASSERT(blob);
blobBuilder->append(blob);
} else {
EXCEPTION_BLOCK(String, stringValue, toWebCoreString(item->ToString()));
blobBuilder->append(stringValue, endings, ASSERT_NO_EXCEPTION);
}
}
RefPtr<Blob> blob = blobBuilder->getBlob(type);
return toV8(blob.get(), args.GetIsolate());
}
