自学教程：C++ v8Undefined函数代码示例

static v8::Handle<v8::Value> saveCallback(const v8::Arguments& args){    if (args.Length() < 3)        return throwNotEnoughArgumentsError(args.GetIsolate());    InspectorFrontendHost* imp = V8InspectorFrontendHost::toNative(args.Holder());    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, url, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, content, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));    V8TRYCATCH(bool, forceSaveAs, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->BooleanValue());    imp->save(url, content, forceSaveAs);    return v8Undefined();}

static v8::Handle<v8::Value> getFrequencyResponseCallback(const v8::Arguments& args){    if (args.Length() < 3)        return throwNotEnoughArgumentsError(args.GetIsolate());    BiquadFilterNode* imp = V8BiquadFilterNode::toNative(args.Holder());    V8TRYCATCH(Float32Array*, frequencyHz, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);    V8TRYCATCH(Float32Array*, magResponse, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined))) : 0);    V8TRYCATCH(Float32Array*, phaseResponse, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);    imp->getFrequencyResponse(frequencyHz, magResponse, phaseResponse);    return v8Undefined();}

static v8::Handle<v8::Value> histogramEnumerationCallback(const v8::Arguments& args){    if (args.Length() < 3)        return throwNotEnoughArgumentsError(args.GetIsolate());    PagePopupController* imp = V8PagePopupController::toNative(args.Holder());    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, name, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));    V8TRYCATCH(int, sample, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));    V8TRYCATCH(int, boundaryValue, toInt32(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)));    imp->histogramEnumeration(name, sample, boundaryValue);    return v8Undefined();}

// A JS object of type EventTarget is limited to a small number of possible classes.v8::Handle<v8::Value> V8DOMWrapper::convertEventTargetToV8Object(EventTarget* target, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate){    if (!target)        return v8NullWithCheck(isolate);    AtomicString desiredInterface = target->interfaceName();    DOM_EVENT_TARGET_INTERFACES_FOR_EACH(TRY_TO_WRAP_WITH_INTERFACE)    ASSERT_NOT_REACHED();    return v8Undefined();}

v8::Handle<v8::Value> V8Console::profileEndCallback(const v8::Arguments& args){    INC_STATS("DOM.Console.profileEnd");    Console* imp = V8Console::toNative(args.Holder());    RefPtr<ScriptCallStack> callStack(createScriptCallStack(1));    if (!callStack)        return v8::Undefined();    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<WithUndefinedOrNullCheck>, title, args[0]);    imp->profileEnd(title, ScriptState::current(), callStack);    return v8Undefined();}

static v8::Handle<v8::Value> start2Callback(const v8::Arguments& args){    FeatureObserver::observe(activeDOMWindow(BindingState::instance()), FeatureObserver::WebAudioStart);    if (args.Length() < 2)        return throwNotEnoughArgumentsError(args.GetIsolate());    AudioBufferSourceNode* imp = V8AudioBufferSourceNode::toNative(args.Holder());    V8TRYCATCH(double, when, static_cast<double>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));    V8TRYCATCH(double, grainOffset, static_cast<double>(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->NumberValue()));    imp->startGrain(when, grainOffset);    return v8Undefined();}

static v8::Handle<v8::Value> setVelocityCallback(const v8::Arguments& args){    if (args.Length() < 3)        return throwNotEnoughArgumentsError(args.GetIsolate());    PannerNode* imp = V8PannerNode::toNative(args.Holder());    V8TRYCATCH(float, x, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));    V8TRYCATCH(float, y, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->NumberValue()));    V8TRYCATCH(float, z, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->NumberValue()));    imp->setVelocity(x, y, z);    return v8Undefined();}

v8::Handle<v8::Value> toV8(EventTarget* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate){    if (!impl)        return v8NullWithCheck(isolate);    AtomicString desiredInterface = impl->interfaceName();    DOM_EVENT_TARGET_INTERFACES_FOR_EACH(TRY_TO_WRAP_WITH_INTERFACE)    ASSERT_NOT_REACHED();    return v8Undefined();}

static v8::Handle<v8::Value> getNthValueOnKeyPath(v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index, v8::Isolate* isolate){    v8::Handle<v8::Value> currentValue(rootValue);    ASSERT(index <= keyPathElements.size());    for (size_t i = 0; i < index; ++i) {        v8::Handle<v8::Value> parentValue(currentValue);        if (!get(parentValue, keyPathElements[i], currentValue, isolate))            return v8Undefined();    }    return currentValue;}

static v8::Handle<v8::Value> clearCallback(const v8::Arguments& args){    RefPtr<SVGStaticListPropertyTearOff<SVGStringList> > imp = V8SVGStringList::toNative(args.Holder());    ExceptionCode ec = 0;    {    imp->clear(ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Handle<v8::Value> acceptTransferListMethod(const v8::Arguments& args){    if (args.Length() < 1)        return throwNotEnoughArgumentsError(args.GetIsolate());    TestSerializedScriptValueInterface* imp = V8TestSerializedScriptValueInterface::toNative(args.Holder());    MessagePortArray messagePortArrayTransferList;    ArrayBufferArray arrayBufferArrayTransferList;    if (args.Length() > 1) {        if (!extractTransferables(args[1], messagePortArrayTransferList, arrayBufferArrayTransferList, args.GetIsolate()))            return throwTypeError("Could not extract transferables", args.GetIsolate());    }    bool dataDidThrow = false;    RefPtr<SerializedScriptValue> data = SerializedScriptValue::create(args[0], &messagePortArrayTransferList, &arrayBufferArrayTransferList, dataDidThrow, args.GetIsolate());    if (dataDidThrow)        return v8Undefined();    if (args.Length() <= 1) {        imp->acceptTransferList(data);        return v8Undefined();    }    imp->acceptTransferList(data, messagePortArrayTransferList);    return v8Undefined();}

static v8::Handle<v8::Value> removeRecursivelyCallback(const v8::Arguments& args){    DirectoryEntrySync* imp = V8DirectoryEntrySync::toNative(args.Holder());    ExceptionCode ec = 0;    {    imp->removeRecursively(ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Handle<v8::Value> getNamedItems(HTMLFormControlsCollection* collection, const AtomicString& name, const CallbackInfo& callbackInfo){    Vector<RefPtr<Node> > namedItems;    collection->namedItems(name, namedItems);    if (!namedItems.size())        return v8Undefined();    if (namedItems.size() == 1)        return toV8(namedItems.at(0).release(), callbackInfo.Holder(), callbackInfo.GetIsolate());    return toV8(collection->ownerNode()->radioNodeList(name).get(), callbackInfo.Holder(), callbackInfo.GetIsolate());}

static v8::Handle<v8::Value> getNamedItems(HTMLFormControlsCollection* collection, const AtomicString& name, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate){    Vector<RefPtr<Node> > namedItems;    collection->namedItems(name, namedItems);    if (!namedItems.size())        return v8Undefined();    if (namedItems.size() == 1)        return toV8(namedItems.at(0).release(), creationContext, isolate);    return toV8(collection->ownerNode()->radioNodeList(name).get(), creationContext, isolate);}

static v8::Handle<v8::Value> webkitEnterFullScreenCallback(const v8::Arguments& args){    HTMLVideoElement* imp = V8HTMLVideoElement::toNative(args.Holder());    ExceptionCode ec = 0;    {    imp->webkitEnterFullScreen(ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Handle<v8::Value> endOfStreamCallback(const v8::Arguments& args){    MediaSource* imp = V8MediaSource::toNative(args.Holder());    ExceptionCode ec = 0;    {    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, error, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsNullString));    imp->endOfStream(error, ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Handle<v8::Value> initMutationEventCallback(const v8::Arguments& args){    MutationEvent* imp = V8MutationEvent::toNative(args.Holder());    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));    V8TRYCATCH(bool, canBubble, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->BooleanValue());    V8TRYCATCH(bool, cancelable, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->BooleanValue());    V8TRYCATCH(Node*, relatedNode, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 3, DefaultIsUndefined)) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 3, DefaultIsUndefined))) : 0);    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, prevValue, MAYBE_MISSING_PARAMETER(args, 4, DefaultIsUndefined));    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, newValue, MAYBE_MISSING_PARAMETER(args, 5, DefaultIsUndefined));    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, attrName, MAYBE_MISSING_PARAMETER(args, 6, DefaultIsUndefined));    V8TRYCATCH(int, attrChange, toUInt32(MAYBE_MISSING_PARAMETER(args, 7, DefaultIsUndefined)));    imp->initMutationEvent(type, canBubble, cancelable, relatedNode, prevValue, newValue, attrName, attrChange);    return v8Undefined();}

static v8::Handle<v8::Value> removeRuleCallback(const v8::Arguments& args){    CSSStyleSheet* imp = V8CSSStyleSheet::toNative(args.Holder());    ExceptionCode ec = 0;    {    V8TRYCATCH(unsigned, index, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));    imp->removeRule(index, ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Handle<v8::Value> deleteCellCallback(const v8::Arguments& args){    HTMLTableRowElement* imp = V8HTMLTableRowElement::toNative(args.Holder());    ExceptionCode ec = 0;    {    V8TRYCATCH(int, index, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));    imp->deleteCell(index, ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Local<v8::Value> getNamedItems(HTMLAllCollection* collection, AtomicString name, const CallbackInfo& info){    WillBeHeapVector<RefPtrWillBeMember<Element>> namedItems;    collection->namedItems(name, namedItems);    if (!namedItems.size())        return v8Undefined();    if (namedItems.size() == 1)        return toV8(namedItems.at(0).release(), info.Holder(), info.GetIsolate());    // FIXME: HTML5 specification says this should be a HTMLCollection.    // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#htmlallcollection    return toV8(StaticElementList::adopt(namedItems), info.Holder(), info.GetIsolate());}

static v8::Handle<v8::Value> setStringValueCallback(const v8::Arguments& args){    CSSPrimitiveValue* imp = V8CSSPrimitiveValue::toNative(args.Holder());    ExceptionCode ec = 0;    {    V8TRYCATCH(int, stringType, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, stringValue, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));    imp->setStringValue(stringType, stringValue, ec);    if (UNLIKELY(ec))        goto fail;    return v8Undefined();    }    fail:    return setDOMException(ec, args.GetIsolate());}

static v8::Handle<v8::Value> getNamedItems(HTMLAllCollection* collection, AtomicString name, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate){    Vector<RefPtr<Node> > namedItems;    collection->namedItems(name, namedItems);    if (!namedItems.size())        return v8Undefined();    if (namedItems.size() == 1)        return toV8(namedItems.at(0).release(), creationContext, isolate);    // FIXME: HTML5 specification says this should be a HTMLCollection.    // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#htmlallcollection    return toV8(V8NamedNodesCollection::create(namedItems), creationContext, isolate);}

static v8::Handle<v8::Value> parentNodeCallback(const v8::Arguments& args){    TreeWalker* imp = V8TreeWalker::toNative(args.Holder());    ScriptState* currentState = ScriptState::current();    if (!currentState)        return v8Undefined();    ScriptState& state = *currentState;    RefPtr<Node> result = imp->parentNode(&state);    if (state.hadException()) {        v8::Local<v8::Value> exception = state.exception();        state.clearException();        return throwError(exception, args.GetIsolate());    }    return toV8(result.release(), args.Holder(), args.GetIsolate());}

v8::Handle<v8::Value> V8DeviceMotionEvent::initDeviceMotionEventCallback(const v8::Arguments& args){    DeviceMotionEvent* imp = V8DeviceMotionEvent::toNative(args.Holder());    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);    bool bubbles = args[1]->BooleanValue();    bool cancelable = args[2]->BooleanValue();    RefPtr<DeviceMotionData::Acceleration> acceleration = readAccelerationArgument(args[3]);    RefPtr<DeviceMotionData::Acceleration> accelerationIncludingGravity = readAccelerationArgument(args[4]);    RefPtr<DeviceMotionData::RotationRate> rotationRate = readRotationRateArgument(args[5]);    bool intervalProvided = !isUndefinedOrNull(args[6]);    double interval = args[6]->NumberValue();    RefPtr<DeviceMotionData> deviceMotionData = DeviceMotionData::create(acceleration, accelerationIncludingGravity, rotationRate, intervalProvided, interval);    imp->initDeviceMotionEvent(type, bubbles, cancelable, deviceMotionData.get());    return v8Undefined();}