Esempio n. 1
0
void AudioParamTimeline::cancelScheduledValues(double startTime, ExceptionState& exceptionState)
{
    ASSERT(isMainThread());

    if (!std::isfinite(startTime)) {
        exceptionState.throwDOMException(
            InvalidStateError,
            "Time must be a finite number: " + String::number(startTime));
    }

    MutexLocker locker(m_eventsLock);

    // Remove all events starting at startTime.
    for (unsigned i = 0; i < m_events.size(); ++i) {
        if (m_events[i].time() >= startTime) {
            m_events.remove(i, m_events.size() - i);
            break;
        }
    }
}
bool FontFaceSet::deleteForBinding(ScriptState*, FontFace* fontFace, ExceptionState& exceptionState)
{
    if (!inActiveDocumentContext())
        return false;
    if (!fontFace) {
        exceptionState.throwTypeError("The argument is not a FontFace.");
        return false;
    }
    WillBeHeapListHashSet<RefPtrWillBeMember<FontFace>>::iterator it = m_nonCSSConnectedFaces.find(fontFace);
    if (it != m_nonCSSConnectedFaces.end()) {
        m_nonCSSConnectedFaces.remove(it);
        CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
        fontSelector->fontFaceCache()->removeFontFace(fontFace, false);
        if (fontFace->loadStatus() == FontFace::Loading)
            removeFromLoadingFonts(fontFace);
        fontSelector->fontFaceInvalidated();
        return true;
    }
    return false;
}
Esempio n. 3
0
void FileWriterSync::write(Blob* data, ExceptionState& exceptionState)
{
    ASSERT(writer());
    ASSERT(m_complete);
    if (!data) {
        exceptionState.throwDOMException(TypeMismatchError, FileError::typeMismatchErrorMessage);
        return;
    }

    prepareForWrite();
    writer()->write(position(), data->uuid());
    ASSERT(m_complete);
    if (m_error) {
        FileError::throwDOMException(exceptionState, m_error);
        return;
    }
    setPosition(position() + data->size());
    if (position() > length())
        setLength(position());
}
void IDBTransaction::abort(ExceptionState& es)
{
    if (m_state == Finishing || m_state == Finished) {
        es.throwDOMException(InvalidStateError, IDBDatabase::transactionFinishedErrorMessage);
        return;
    }

    m_state = Finishing;

    if (!m_contextStopped) {
        while (!m_requestList.isEmpty()) {
            RefPtr<IDBRequest> request = *m_requestList.begin();
            m_requestList.remove(request);
            request->abort();
        }
    }

    RefPtr<IDBTransaction> selfRef = this;
    backendDB()->abort(m_id);
}
Esempio n. 5
0
void IDBCursor::continueFunction(IDBKey* key, IDBKey* primaryKey, ExceptionState& exceptionState)
{
    ASSERT(!primaryKey || (key && primaryKey));

    if (m_transaction->isFinished() || m_transaction->isFinishing()) {
        exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
        return;
    }
    if (!m_transaction->isActive()) {
        exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
        return;
    }

    if (!m_gotValue) {
        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
        return;
    }

    if (isDeleted()) {
        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
        return;
    }

    if (key) {
        ASSERT(m_key);
        if (m_direction == WebIDBCursorDirectionNext || m_direction == WebIDBCursorDirectionNextNoDuplicate) {
            const bool ok = m_key->isLessThan(key)
                || (primaryKey && m_key->isEqual(key) && m_primaryKey->isLessThan(primaryKey));
            if (!ok) {
                exceptionState.throwDOMException(DataError, "The parameter is less than or equal to this cursor's position.");
                return;
            }

        } else {
            const bool ok = key->isLessThan(m_key.get())
                || (primaryKey && key->isEqual(m_key.get()) && primaryKey->isLessThan(m_primaryKey.get()));
            if (!ok) {
                exceptionState.throwDOMException(DataError, "The parameter is greater than or equal to this cursor's position.");
                return;
            }
        }
    }

    // FIXME: We're not using the context from when continue was called, which means the callback
    //        will be on the original context openCursor was called on. Is this right?
    m_request->setPendingCursor(this);
    m_gotValue = false;
    m_backend->continueFunction(key, primaryKey, WebIDBCallbacksImpl::create(m_request).leakPtr());
}
PassRefPtrWillBeRawPtr<FontFaceSet> FontFaceSet::addForBinding(ScriptState*, FontFace* fontFace, ExceptionState& exceptionState)
{
    if (!inActiveDocumentContext())
        return this;
    if (!fontFace) {
        exceptionState.throwTypeError("The argument is not a FontFace.");
        return this;
    }
    if (m_nonCSSConnectedFaces.contains(fontFace))
        return this;
    if (isCSSConnectedFontFace(fontFace))
        return this;
    CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
    m_nonCSSConnectedFaces.add(fontFace);
    fontSelector->fontFaceCache()->addFontFace(fontSelector, fontFace, false);
    if (fontFace->loadStatus() == FontFace::Loading)
        addToLoadingFonts(fontFace);
    fontSelector->fontFaceInvalidated();
    return this;
}
Esempio n. 7
0
PassRefPtr<Database> DOMWindowWebDatabase::openDatabase(DOMWindow& window, const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassOwnPtr<DatabaseCallback> creationCallback, ExceptionState& exceptionState)
{
    if (!window.isCurrentlyDisplayedInFrame())
        return nullptr;

    RefPtr<Database> database = nullptr;
    DatabaseManager& dbManager = DatabaseManager::manager();
    DatabaseError error = DatabaseError::None;
    if (RuntimeEnabledFeatures::databaseEnabled() && window.document()->securityOrigin()->canAccessDatabase()) {
        String errorMessage;
        database = dbManager.openDatabase(window.document(), name, version, displayName, estimatedSize, creationCallback, error, errorMessage);
        ASSERT(database || error != DatabaseError::None);
        if (error != DatabaseError::None)
            DatabaseManager::throwExceptionForDatabaseError(error, errorMessage, exceptionState);
    } else {
        exceptionState.throwSecurityError("Access to the WebDatabase API is denied in this context.");
    }

    return database;
}
Esempio n. 8
0
void StereoPannerHandler::setChannelCount(unsigned long channelCount,
                                          ExceptionState& exceptionState) {
  DCHECK(isMainThread());
  BaseAudioContext::AutoLocker locker(context());

  // A PannerNode only supports 1 or 2 channels
  if (channelCount > 0 && channelCount <= 2) {
    if (m_channelCount != channelCount) {
      m_channelCount = channelCount;
      if (internalChannelCountMode() != Max)
        updateChannelsForInputs();
    }
  } else {
    exceptionState.throwDOMException(
        NotSupportedError,
        ExceptionMessages::indexOutsideRange<unsigned long>(
            "channelCount", channelCount, 1, ExceptionMessages::InclusiveBound,
            2, ExceptionMessages::InclusiveBound));
  }
}
Esempio n. 9
0
void RTCPeerConnection::removeStream(PassRefPtr<MediaStream> prpStream, ExceptionState& exceptionState)
{
    if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
        return;

    if (!prpStream) {
        exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "MediaStream"));
        return;
    }

    RefPtr<MediaStream> stream = prpStream;

    size_t pos = m_localStreams.find(stream);
    if (pos == kNotFound)
        return;

    m_localStreams.remove(pos);

    m_peerHandler->removeStream(stream->descriptor());
}
Esempio n. 10
0
float SVGLengthContext::convertValueFromPercentageToUserUnits(float value, SVGLengthMode mode, ExceptionState& exceptionState) const
{
    FloatSize viewportSize;
    if (!determineViewport(viewportSize)) {
        exceptionState.throwDOMException(NotSupportedError, "The viewport could not be determined.");
        return 0;
    }

    switch (mode) {
    case LengthModeWidth:
        return value * viewportSize.width();
    case LengthModeHeight:
        return value * viewportSize.height();
    case LengthModeOther:
        return value * sqrtf(viewportSize.diagonalLengthSquared() / 2);
    };

    ASSERT_NOT_REACHED();
    return 0;
}
Esempio n. 11
0
bool DOMMatrixReadOnly::validateAndFixup(DOMMatrixInit& other,
                                         ExceptionState& exceptionState) {
  if (other.hasA() && other.hasM11() && other.a() != other.m11()) {
    exceptionState.throwTypeError(getErrorMessage("a", "m11"));
    return false;
  }
  if (other.hasB() && other.hasM12() && other.b() != other.m12()) {
    exceptionState.throwTypeError(getErrorMessage("b", "m12"));
    return false;
  }
  if (other.hasC() && other.hasM21() && other.c() != other.m21()) {
    exceptionState.throwTypeError(getErrorMessage("c", "m21"));
    return false;
  }
  if (other.hasD() && other.hasM22() && other.d() != other.m22()) {
    exceptionState.throwTypeError(getErrorMessage("d", "m22"));
    return false;
  }
  if (other.hasE() && other.hasM41() && other.e() != other.m41()) {
    exceptionState.throwTypeError(getErrorMessage("e", "m41"));
    return false;
  }
  if (other.hasF() && other.hasM42() && other.f() != other.m42()) {
    exceptionState.throwTypeError(getErrorMessage("f", "m42"));
    return false;
  }
  if (other.hasIs2D() && other.is2D() &&
      (other.m31() || other.m32() || other.m13() || other.m23() ||
       other.m43() || other.m14() || other.m24() || other.m34() ||
       other.m33() != 1 || other.m44() != 1)) {
    exceptionState.throwTypeError(
        "The is2D member is set to true but the input matrix is 3d matrix.");
    return false;
  }

  setDictionaryMembers(other);
  if (!other.hasIs2D()) {
    bool is2D = !(other.m31() || other.m32() || other.m13() || other.m23() ||
                  other.m43() || other.m14() || other.m24() || other.m34() ||
                  other.m33() != 1 || other.m44() != 1);
    other.setIs2D(is2D);
  }
  return true;
}
Esempio n. 12
0
void InternalSettings::setDisplayModeOverride(const String& displayMode,
                                              ExceptionState& exceptionState) {
  InternalSettingsGuardForSettings();
  String token = displayMode.stripWhiteSpace();

  WebDisplayMode mode = WebDisplayModeBrowser;
  if (token == "browser")
    mode = WebDisplayModeBrowser;
  else if (token == "minimal-ui")
    mode = WebDisplayModeMinimalUi;
  else if (token == "standalone")
    mode = WebDisplayModeStandalone;
  else if (token == "fullscreen")
    mode = WebDisplayModeFullscreen;
  else
    exceptionState.throwDOMException(
        SyntaxError, "The display-mode token ('" + token + ")' is invalid.");

  settings()->setDisplayModeOverride(mode);
}
Esempio n. 13
0
void InternalSettings::setTextTrackKindUserPreference(
    const String& preference,
    ExceptionState& exceptionState) {
  InternalSettingsGuardForSettings();
  String token = preference.stripWhiteSpace();
  TextTrackKindUserPreference userPreference =
      TextTrackKindUserPreference::Default;
  if (token == "default")
    userPreference = TextTrackKindUserPreference::Default;
  else if (token == "captions")
    userPreference = TextTrackKindUserPreference::Captions;
  else if (token == "subtitles")
    userPreference = TextTrackKindUserPreference::Subtitles;
  else
    exceptionState.throwDOMException(
        SyntaxError, "The user preference for text track kind " + preference +
                         ")' is invalid.");

  settings()->setTextTrackKindUserPreference(userPreference);
}
Esempio n. 14
0
void WebCLProgram::release(ExceptionState& es) {
    cl_int err = 0;

    if (m_cl_program == NULL) {
        printf("Error: Invalid program object\n");
        es.throwWebCLException(
                WebCLException::INVALID_DEVICE,
                WebCLException::invalidDeviceMessage);
        return;
    }
    err = clReleaseProgram(m_cl_program);
    
    if (err != CL_SUCCESS) {
        WebCLException::throwException(err, es);
    } else {
        m_cl_program = NULL;
        isReleased = true;
        return;
    }
    return;
}
Esempio n. 15
0
void SVGLengthList::parseInternal(const CharType*& ptr, const CharType* end, ExceptionState& exceptionState)
{
    clear();
    while (ptr < end) {
        const CharType* start = ptr;
        while (ptr < end && *ptr != ',' && !isHTMLSpace<CharType>(*ptr))
            ptr++;
        if (ptr == start)
            break;

        RefPtr<SVGLength> length = SVGLength::create(m_mode);
        String valueString(start, ptr - start);
        if (valueString.isEmpty())
            return;
        length->setValueAsString(valueString, exceptionState);
        if (exceptionState.hadException())
            return;
        append(length);
        skipOptionalSVGSpacesOrDelimiter(ptr, end);
    }
}
Esempio n. 16
0
void MediaController::setPlaybackRate(double rate, ExceptionState& exceptionState)
{
    // FIXME: generated bindings should check isfinite: http://crbug.com/354298
    if (!std::isfinite(rate)) {
        exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(rate));
        return;
    }

    if (m_clock->playRate() == rate)
        return;

    // The playbackRate attribute, on setting, must set the MediaController's media controller
    // playback rate to the new value,
    m_clock->setPlayRate(rate);

    for (size_t index = 0; index < m_mediaElements.size(); ++index)
        m_mediaElements[index]->updatePlaybackRate();

    // then queue a task to fire a simple event named ratechange at the MediaController.
    scheduleEvent(EventTypeNames::ratechange);
}
PassRefPtrWillBeRawPtr<Range> DOMSelection::getRangeAt(int index, ExceptionState& exceptionState)
{
    if (!m_frame)
        return nullptr;

    if (index < 0 || index >= rangeCount()) {
        exceptionState.throwDOMException(IndexSizeError, String::number(index) + " is not a valid index.");
        return nullptr;
    }

    // If you're hitting this, you've added broken multi-range selection support
    ASSERT(rangeCount() == 1);

    Position anchor = anchorPosition(visibleSelection());
    if (!anchor.anchorNode()->isInShadowTree())
        return m_frame->selection().firstRange();

    if (!visibleSelection().isBaseFirst())
        return Range::create(*anchor.document(), focusNode(), focusOffset(), shadowAdjustedNode(anchor), anchorOffset());
    return Range::create(*anchor.document(), shadowAdjustedNode(anchor), anchorOffset(), focusNode(), focusOffset());
}
Esempio n. 18
0
void HTMLElement::setOuterText(const String &text, ExceptionState& es)
{
    if (ieForbidsInsertHTML()) {
        es.throwDOMException(NoModificationAllowedError);
        return;
    }
    if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
        hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) ||
        hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
        hasLocalName(trTag)) {
        es.throwDOMException(NoModificationAllowedError);
        return;
    }

    ContainerNode* parent = parentNode();
    if (!parent) {
        es.throwDOMException(NoModificationAllowedError);
        return;
    }

    RefPtr<Node> prev = previousSibling();
    RefPtr<Node> next = nextSibling();
    RefPtr<Node> newChild;

    // Convert text to fragment with <br> tags instead of linebreaks if needed.
    if (text.contains('\r') || text.contains('\n'))
        newChild = textToFragment(text, es);
    else
        newChild = Text::create(document(), text);

    if (!this || !parentNode())
        es.throwDOMException(HierarchyRequestError);
    if (es.hadException())
        return;
    parent->replaceChild(newChild.release(), this, es);

    RefPtr<Node> node = next ? next->previousSibling() : 0;
    if (!es.hadException() && node && node->isTextNode())
        mergeWithNextTextNode(node.release(), es);

    if (!es.hadException() && prev && prev->isTextNode())
        mergeWithNextTextNode(prev.release(), es);
}
Esempio n. 19
0
Pattern::RepeatMode CanvasPattern::parseRepetitionType(
    const String& type,
    ExceptionState& exceptionState) {
  if (type.isEmpty() || type == "repeat")
    return Pattern::RepeatModeXY;

  if (type == "no-repeat")
    return Pattern::RepeatModeNone;

  if (type == "repeat-x")
    return Pattern::RepeatModeX;

  if (type == "repeat-y")
    return Pattern::RepeatModeY;

  exceptionState.throwDOMException(
      SyntaxError,
      "The provided type ('" + type +
          "') is not one of 'repeat', 'no-repeat', 'repeat-x', or 'repeat-y'.");
  return Pattern::RepeatModeNone;
}
Esempio n. 20
0
void V8NodeOrNodeList::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, NodeOrNodeList& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState) {
  if (v8Value.IsEmpty())
    return;

  if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
    return;

  if (V8Node::hasInstance(v8Value, isolate)) {
    Node* cppValue = V8Node::toImpl(v8::Local<v8::Object>::Cast(v8Value));
    impl.setNode(cppValue);
    return;
  }

  if (V8NodeList::hasInstance(v8Value, isolate)) {
    NodeList* cppValue = V8NodeList::toImpl(v8::Local<v8::Object>::Cast(v8Value));
    impl.setNodeList(cppValue);
    return;
  }

  exceptionState.throwTypeError("The provided value is not of type '(Node or NodeList)'");
}
Esempio n. 21
0
void AnimationPlayer::finish(ExceptionState& exceptionState)
{
    PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand);

    if (!m_playbackRate || playStateInternal() == Idle) {
        return;
    }
    if (m_playbackRate > 0 && sourceEnd() == std::numeric_limits<double>::infinity()) {
        exceptionState.throwDOMException(InvalidStateError, "AnimationPlayer has source content whose end time is infinity.");
        return;
    }

    double newCurrentTime = m_playbackRate < 0 ? 0 : sourceEnd();
    setCurrentTimeInternal(newCurrentTime, TimingUpdateOnDemand);
    if (!paused()) {
        m_startTime = calculateStartTime(newCurrentTime);
    }

    m_currentTimePending = false;
    ASSERT(finished());
}
Esempio n. 22
0
void HTMLElement::setOuterText(const String& text, ExceptionState& exceptionState)
{
    if (ieForbidsInsertHTML()) {
        exceptionState.throwDOMException(NoModificationAllowedError, "The '" + localName() + "' element does not support text insertion.");
        return;
    }
    if (shouldProhibitSetInnerOuterText(*this)) {
        exceptionState.throwDOMException(NoModificationAllowedError, "The '" + localName() + "' element does not support text insertion.");
        return;
    }

    ContainerNode* parent = parentNode();
    if (!parent) {
        exceptionState.throwDOMException(NoModificationAllowedError, "The element has no parent.");
        return;
    }

    RefPtrWillBeRawPtr<Node> prev = previousSibling();
    RefPtrWillBeRawPtr<Node> next = nextSibling();
    RefPtrWillBeRawPtr<Node> newChild = nullptr;

    // Convert text to fragment with <br> tags instead of linebreaks if needed.
    if (text.contains('\r') || text.contains('\n'))
        newChild = textToFragment(text, exceptionState);
    else
        newChild = Text::create(document(), text);

    // textToFragment might cause mutation events.
    if (!parentNode())
        exceptionState.throwDOMException(HierarchyRequestError, "The element has no parent.");

    if (exceptionState.hadException())
        return;

    parent->replaceChild(newChild.release(), this, exceptionState);

    RefPtrWillBeRawPtr<Node> node = next ? next->previousSibling() : nullptr;
    if (!exceptionState.hadException() && node && node->isTextNode())
        mergeWithNextTextNode(toText(node.get()), exceptionState);

    if (!exceptionState.hadException() && prev && prev->isTextNode())
        mergeWithNextTextNode(toText(prev.get()), exceptionState);
}
Esempio n. 23
0
void WebCLEvent::release(ExceptionState& es) {
    cl_int err = 0;
    
    if (m_cl_Event == NULL) {
        printf("Error: Invalid CL Event\n");
        es.throwWebCLException(
                WebCLException::INVALID_EVENT,
                WebCLException::invalidEventMessage);
        return;
    }
    err = clReleaseEvent(m_cl_Event);
    
    if (err != CL_SUCCESS) {
        WebCLException::throwException(err, es);
    } else {
        isReleased = true;
        m_cl_Event = NULL;
        return;
    }
    return;
}
Esempio n. 24
0
void SVGPointList::setValueAsString(const String& value, ExceptionState& exceptionState)
{
    if (value.isEmpty()) {
        clear();
        return;
    }

    bool valid = false;
    if (value.is8Bit()) {
        const LChar* ptr = value.characters8();
        const LChar* end = ptr + value.length();
        valid = parse(ptr, end);
    } else {
        const UChar* ptr = value.characters16();
        const UChar* end = ptr + value.length();
        valid = parse(ptr, end);
    }

    if (!valid)
        exceptionState.throwDOMException(SyntaxError, "Problem parsing points=\""+value+"\"");
}
float SVGLengthContext::convertValueFromPercentageToUserUnits(float value, SVGLengthMode mode, ExceptionState& es) const
{
    float width = 0;
    float height = 0;
    if (!determineViewport(width, height)) {
        es.throwDOMException(NotSupportedError);
        return 0;
    }

    switch (mode) {
    case LengthModeWidth:
        return value * width;
    case LengthModeHeight:
        return value * height;
    case LengthModeOther:
        return value * sqrtf((width * width + height * height) / 2);
    };

    ASSERT_NOT_REACHED();
    return 0;
}
Esempio n. 26
0
void Blob::close(ExecutionContext* executionContext, ExceptionState& exceptionState)
{
    if (hasBeenClosed()) {
        exceptionState.throwDOMException(InvalidStateError, "Blob has been closed.");
        return;
    }

    // Dereferencing a Blob that has been closed should result in
    // a network error. Revoke URLs registered against it through
    // its UUID.
    DOMURL::revokeObjectUUID(executionContext, uuid());

    // A Blob enters a 'readability state' of closed, where it will report its
    // size as zero. Blob and FileReader operations now throws on
    // being passed a Blob in that state. Downstream uses of closed Blobs
    // (e.g., XHR.send()) consider them as empty.
    OwnPtr<BlobData> blobData = BlobData::create();
    blobData->setContentType(type());
    m_blobDataHandle = BlobDataHandle::create(blobData.release(), 0);
    m_hasBeenClosed = true;
}
void IDBTransaction::abort(ExceptionState& exceptionState)
{
    if (m_state == Finishing || m_state == Finished) {
        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::transactionFinishedErrorMessage);
        return;
    }

    m_state = Finishing;

    if (m_contextStopped)
        return;

    while (!m_requestList.isEmpty()) {
        IDBRequest* request = *m_requestList.begin();
        m_requestList.remove(request);
        request->abort();
    }

    if (backendDB())
        backendDB()->abort(m_id);
}
Esempio n. 28
0
PassRefPtrWillBeRawPtr<IDBRequest> IDBCursor::update(ExecutionContext* executionContext, ScriptValue& value, ExceptionState& exceptionState)
{
    IDB_TRACE("IDBCursor::update");

    if (!m_gotValue) {
        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
        return nullptr;
    }
    if (isKeyCursor()) {
        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
        return nullptr;
    }
    if (isDeleted()) {
        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
        return nullptr;
    }
    if (m_transaction->isFinished() || m_transaction->isFinishing()) {
        exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
        return nullptr;
    }
    if (!m_transaction->isActive()) {
        exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
        return nullptr;
    }
    if (m_transaction->isReadOnly()) {
        exceptionState.throwDOMException(ReadOnlyError, "The record may not be updated inside a read-only transaction.");
        return nullptr;
    }

    RefPtrWillBeRawPtr<IDBObjectStore> objectStore = effectiveObjectStore();
    const IDBKeyPath& keyPath = objectStore->metadata().keyPath;
    const bool usesInLineKeys = !keyPath.isNull();
    if (usesInLineKeys) {
        RefPtrWillBeRawPtr<IDBKey> keyPathKey = createIDBKeyFromScriptValueAndKeyPath(toIsolate(executionContext), value, keyPath);
        if (!keyPathKey || !keyPathKey->isEqual(m_primaryKey.get())) {
            exceptionState.throwDOMException(DataError, "The effective object store of this cursor uses in-line keys and evaluating the key path of the value parameter results in a different value than the cursor's effective key.");
            return nullptr;
        }
    }

    return objectStore->put(executionContext, WebIDBDatabase::CursorUpdate, IDBAny::create(this), value, m_primaryKey, exceptionState);
}
Esempio n. 29
0
void SourceBuffer::setAppendWindowStart(double start, ExceptionState& exceptionState)
{
    // Section 3.1 appendWindowStart attribute setter steps.
    // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-SourceBuffer-appendWindowStart
    // 1. If this object has been removed from the sourceBuffers attribute of the parent media source then throw an
    //    InvalidStateError exception and abort these steps.
    // 2. If the updating attribute equals true, then throw an InvalidStateError exception and abort these steps.
    if (throwExceptionIfRemovedOrUpdating(isRemoved(), m_updating, exceptionState))
        return;

    // 3. If the new value is less than 0 or greater than or equal to appendWindowEnd then throw an InvalidAccessError
    //    exception and abort these steps.
    if (start < 0 || start >= m_appendWindowEnd) {
        exceptionState.throwDOMException(InvalidAccessError, ExceptionMessages::indexOutsideRange("value", start, 0.0, ExceptionMessages::ExclusiveBound, m_appendWindowEnd, ExceptionMessages::InclusiveBound));
        return;
    }

    m_webSourceBuffer->setAppendWindowStart(start);

    // 4. Update the attribute to the new value.
    m_appendWindowStart = start;
}
float SVGLengthContext::convertValueToUserUnits(float value, SVGLengthMode mode, SVGLengthType fromUnit, ExceptionState& es) const
{
    // If the SVGLengthContext carries a custom viewport, force resolving against it.
    if (!m_overridenViewport.isEmpty()) {
        // 100% = 100.0 instead of 1.0 for historical reasons, this could eventually be changed
        if (fromUnit == LengthTypePercentage)
            value /= 100;
        return convertValueFromPercentageToUserUnits(value, mode, es);
    }

    switch (fromUnit) {
    case LengthTypeUnknown:
        es.throwDOMException(NotSupportedError);
        return 0;
    case LengthTypeNumber:
        return value;
    case LengthTypePX:
        return value;
    case LengthTypePercentage:
        return convertValueFromPercentageToUserUnits(value / 100, mode, es);
    case LengthTypeEMS:
        return convertValueFromEMSToUserUnits(value, es);
    case LengthTypeEXS:
        return convertValueFromEXSToUserUnits(value, es);
    case LengthTypeCM:
        return value * cssPixelsPerInch / 2.54f;
    case LengthTypeMM:
        return value * cssPixelsPerInch / 25.4f;
    case LengthTypeIN:
        return value * cssPixelsPerInch;
    case LengthTypePT:
        return value * cssPixelsPerInch / 72;
    case LengthTypePC:
        return value * cssPixelsPerInch / 6;
    }

    ASSERT_NOT_REACHED();
    return 0;
}