void InspectorDebuggerAgent::scriptExecutionBlockedByCSP(const String& directiveText)
{
if (m_v8DebuggerAgent->debugger().pauseOnExceptionsState() == V8Debugger::DontPauseOnExceptions)
return;
RefPtr<JSONObject> directive = JSONObject::create();
directive->setString("directiveText", directiveText);
m_v8DebuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::CSPViolation, directive.release());
}
void EwkView::setCursor(const Cursor& cursor)
{
if (cursor.image()) {
// Custom cursor.
if (cursor.image() == m_cursorIdentifier)
return;
m_cursorIdentifier = cursor.image();
Ewk_View_Smart_Data* sd = smartData();
RefPtr<Evas_Object> cursorObject = adoptRef(cursor.image()->getEvasObject(sd->base.evas));
if (!cursorObject)
return;
// Resize cursor.
evas_object_resize(cursorObject.get(), cursor.image()->size().width(), cursor.image()->size().height());
// Get cursor hot spot.
IntPoint hotSpot;
cursor.image()->getHotSpot(hotSpot);
Ecore_Evas* ecoreEvas = ecore_evas_ecore_evas_get(sd->base.evas);
// ecore_evas takes care of freeing the cursor object.
ecore_evas_object_cursor_set(ecoreEvas, cursorObject.release().leakRef(), EVAS_LAYER_MAX, hotSpot.x(), hotSpot.y());
return;
}
// Standard cursor.
const char* group = cursor.platformCursor();
if (!group || group == m_cursorIdentifier)
return;
m_cursorIdentifier = group;
Ewk_View_Smart_Data* sd = smartData();
RefPtr<Evas_Object> cursorObject = adoptRef(edje_object_add(sd->base.evas));
Ecore_Evas* ecoreEvas = ecore_evas_ecore_evas_get(sd->base.evas);
if (!m_theme || !edje_object_file_set(cursorObject.get(), m_theme, group)) {
ecore_evas_object_cursor_set(ecoreEvas, 0, 0, 0, 0);
#ifdef HAVE_ECORE_X
if (WebCore::isUsingEcoreX(sd->base.evas))
WebCore::applyFallbackCursor(ecoreEvas, group);
#endif
return;
}
// Set cursor size.
Evas_Coord width, height;
edje_object_size_min_get(cursorObject.get(), &width, &height);
if (width <= 0 || height <= 0)
edje_object_size_min_calc(cursorObject.get(), &width, &height);
if (width <= 0 || height <= 0) {
width = defaultCursorSize;
height = defaultCursorSize;
}
evas_object_resize(cursorObject.get(), width, height);
// Get cursor hot spot.
const char* data;
int hotspotX = 0;
data = edje_object_data_get(cursorObject.get(), "hot.x");
if (data)
hotspotX = atoi(data);
int hotspotY = 0;
data = edje_object_data_get(cursorObject.get(), "hot.y");
if (data)
hotspotY = atoi(data);
// ecore_evas takes care of freeing the cursor object.
ecore_evas_object_cursor_set(ecoreEvas, cursorObject.release().leakRef(), EVAS_LAYER_MAX, hotspotX, hotspotY);
}
void InsertParagraphSeparatorCommand::doApply()
{
bool splitText = false;
if (endingSelection().isNone())
return;
Position pos = endingSelection().start();
EAffinity affinity = endingSelection().affinity();
// Delete the current selection.
if (endingSelection().isRange()) {
calculateStyleBeforeInsertion(pos);
deleteSelection(false, true);
pos = endingSelection().start();
affinity = endingSelection().affinity();
}
// FIXME: Turn into an InsertLineBreak in other cases where we don't want to do the splitting/cloning that
// InsertParagraphSeparator does.
Node* block = enclosingBlock(pos.node());
Position canonicalPos = VisiblePosition(pos).deepEquivalent();
if (!block || !block->parentNode() ||
block->renderer() && block->renderer()->isTableCell() ||
canonicalPos.node()->renderer() && canonicalPos.node()->renderer()->isTable() ||
canonicalPos.node()->hasTagName(hrTag)) {
applyCommandToComposite(new InsertLineBreakCommand(document()));
return;
}
// Use the leftmost candidate.
pos = pos.upstream();
if (!pos.isCandidate())
pos = pos.downstream();
// Adjust the insertion position after the delete
pos = positionAvoidingSpecialElementBoundary(pos);
VisiblePosition visiblePos(pos, affinity);
calculateStyleBeforeInsertion(pos);
//---------------------------------------------------------------------
// Handle special case of typing return on an empty list item
if (breakOutOfEmptyListItem())
return;
//---------------------------------------------------------------------
// Prepare for more general cases.
Node *startNode = pos.node();
Node *startBlock = startNode->enclosingBlockFlowElement();
bool isFirstInBlock = isStartOfBlock(visiblePos);
bool isLastInBlock = isEndOfBlock(visiblePos);
bool nestNewBlock = false;
// Create block to be inserted.
RefPtr<Node> blockToInsert;
if (startBlock == startBlock->rootEditableElement()) {
blockToInsert = static_pointer_cast<Node>(createDefaultParagraphElement(document()));
nestNewBlock = true;
} else
blockToInsert = startBlock->cloneNode(false);
//---------------------------------------------------------------------
// Handle case when position is in the last visible position in its block,
// including when the block is empty.
if (isLastInBlock) {
if (nestNewBlock) {
if (isFirstInBlock) {
// block is empty: create an empty paragraph to
// represent the content before the new one.
RefPtr<Node> extraBlock = createDefaultParagraphElement(document());
appendNode(extraBlock.get(), startBlock);
appendBlockPlaceholder(extraBlock.get());
}
appendNode(blockToInsert.get(), startBlock);
} else
insertNodeAfter(blockToInsert.get(), startBlock);
appendBlockPlaceholder(blockToInsert.get());
setEndingSelection(Selection(Position(blockToInsert.get(), 0), DOWNSTREAM));
applyStyleAfterInsertion();
return;
}
//---------------------------------------------------------------------
// Handle case when position is in the first visible position in its block, and
// similar case where previous position is in another, presumeably nested, block.
if (isFirstInBlock || !inSameBlock(visiblePos, visiblePos.previous())) {
pos = pos.downstream();
Position refPos;
Node *refNode;
if (isFirstInBlock && !nestNewBlock)
refNode = startBlock;
else if (pos.node() == startBlock && nestNewBlock) {
refNode = startBlock->childNode(pos.offset());
ASSERT(refNode); // must be true or we'd be in the end of block case
} else
refNode = pos.node();
insertNodeBefore(blockToInsert.get(), refNode);
appendBlockPlaceholder(blockToInsert.get());
setEndingSelection(Selection(Position(blockToInsert.get(), 0), DOWNSTREAM));
applyStyleAfterInsertion();
setEndingSelection(Selection(pos, DOWNSTREAM));
return;
}
//---------------------------------------------------------------------
// Handle the (more complicated) general case,
Position upstreamPos = pos.upstream();
if (upstreamPos.node()->hasTagName(brTag)) {
RefPtr<Element> br = createBreakElement(document());
insertNodeAfter(br.get(), upstreamPos.node());
pos = positionAfterNode(br.get());
}
// Move downstream. Typing style code will take care of carrying along the
// style of the upstream position.
pos = pos.downstream();
startNode = pos.node();
// Build up list of ancestors in between the start node and the start block.
Vector<Node*> ancestors;
if (startNode != startBlock)
for (Node* n = startNode->parentNode(); n && n != startBlock; n = n->parentNode())
ancestors.append(n);
// Make sure we do not cause a rendered space to become unrendered.
// FIXME: We need the affinity for pos, but pos.downstream() does not give it
Position leadingWhitespace = pos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY);
// FIXME: leadingWhitespacePosition is returning the position before preserved newlines for positions
// after the preserved newline, causing the newline to be turned into a nbsp.
if (leadingWhitespace.isNotNull()) {
Text* textNode = static_cast<Text*>(leadingWhitespace.node());
ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
replaceTextInNode(textNode, leadingWhitespace.offset(), 1, nonBreakingSpaceString());
}
// Split at pos if in the middle of a text node.
if (startNode->isTextNode()) {
Text *textNode = static_cast<Text *>(startNode);
bool atEnd = (unsigned)pos.offset() >= textNode->length();
if (pos.offset() > 0 && !atEnd) {
splitTextNode(textNode, pos.offset());
pos = Position(startNode, 0);
visiblePos = VisiblePosition(pos);
splitText = true;
}
}
// Put the added block in the tree.
if (nestNewBlock)
appendNode(blockToInsert.get(), startBlock);
else
insertNodeAfter(blockToInsert.get(), startBlock);
// Make clones of ancestors in between the start node and the start block.
RefPtr<Node> parent = blockToInsert;
for (size_t i = ancestors.size(); i != 0; --i) {
RefPtr<Node> child = ancestors[i - 1]->cloneNode(false); // shallow clone
appendNode(child.get(), parent.get());
parent = child.release();
}
// If the paragraph separator was inserted at the end of a paragraph, an empty line must be
// created. All of the nodes, starting at visiblePos, are about to be added to the new paragraph
// element. If the first node to be inserted won't be one that will hold an empty line open, add a br.
if (isEndOfParagraph(visiblePos) && !startNode->hasTagName(brTag) &&
!(startNode->renderer()->style()->preserveNewline() && visiblePos.characterAfter() == '\n'))
appendNode(createBreakElement(document()).get(), blockToInsert.get());
// Move the start node and the siblings of the start node.
if (startNode != startBlock) {
Node *n = startNode;
if (pos.offset() >= startNode->caretMaxOffset())
n = startNode->nextSibling();
while (n && n != blockToInsert) {
Node *next = n->nextSibling();
removeNode(n);
appendNode(n, parent.get());
n = next;
}
}
// Move everything after the start node.
if (!ancestors.isEmpty()) {
Node* leftParent = ancestors.first();
while (leftParent && leftParent != startBlock) {
parent = parent->parentNode();
Node* n = leftParent->nextSibling();
while (n && n != blockToInsert) {
Node* next = n->nextSibling();
removeNode(n);
appendNode(n, parent.get());
n = next;
}
leftParent = leftParent->parentNode();
}
}
// Handle whitespace that occurs after the split
if (splitText) {
updateLayout();
pos = Position(startNode, 0);
if (!pos.isRenderedCharacter()) {
// Clear out all whitespace and insert one non-breaking space
ASSERT(startNode);
ASSERT(startNode->isTextNode());
ASSERT(!startNode->renderer() || startNode->renderer()->style()->collapseWhiteSpace());
deleteInsignificantTextDownstream(pos);
insertTextIntoNode(static_cast<Text*>(startNode), 0, nonBreakingSpaceString());
}
}
setEndingSelection(Selection(Position(blockToInsert.get(), 0), DOWNSTREAM));
applyStyleAfterInsertion();
}
void PeerConnection00::didAddRemoteStream(PassRefPtr<MediaStreamDescriptor> streamDescriptor)
{
ASSERT(scriptExecutionContext()->isContextThread());
if (m_readyState == CLOSED)
return;
RefPtr<MediaStream> stream = MediaStream::create(scriptExecutionContext(), streamDescriptor);
m_remoteStreams->append(stream);
dispatchEvent(MediaStreamEvent::create(eventNames().addstreamEvent, false, false, stream.release()));
}
PassRefPtr<PeerConnection00> PeerConnection00::create(ScriptExecutionContext* context, const String& serverConfiguration, PassRefPtr<IceCallback> iceCallback)
{
RefPtr<PeerConnection00> peerConnection = adoptRef(new PeerConnection00(context, serverConfiguration, iceCallback));
peerConnection->suspendIfNeeded();
return peerConnection.release();
}
bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder, WebCore::FilterOperations& filters)
{
uint32_t size;
if (!decoder->decodeUInt32(size))
return false;
Vector<RefPtr<FilterOperation> >& operations = filters.operations();
for (size_t i = 0; i < size; ++i) {
FilterOperation::OperationType type;
RefPtr<FilterOperation> filter;
if (!decoder->decodeEnum(type))
return false;
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE: {
double value;
if (!decoder->decodeDouble(value))
return false;
filter = BasicColorMatrixFilterOperation::create(value, type);
break;
}
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY: {
double value;
if (!decoder->decodeDouble(value))
return false;
filter = BasicComponentTransferFilterOperation::create(value, type);
break;
}
case FilterOperation::BLUR: {
Length length;
if (!ArgumentCoder<Length>::decode(decoder, length))
return false;
filter = BlurFilterOperation::create(length, type);
break;
}
case FilterOperation::DROP_SHADOW: {
IntPoint location;
int32_t stdDeviation;
Color color;
if (!ArgumentCoder<IntPoint>::decode(decoder, location))
return false;
if (!decoder->decodeInt32(stdDeviation))
return false;
if (!ArgumentCoder<Color>::decode(decoder, color))
return false;
filter = DropShadowFilterOperation::create(location, stdDeviation, color, type);
break;
}
#if ENABLE(CSS_SHADERS)
case FilterOperation::CUSTOM: {
String vertexShaderString;
String fragmentShaderString;
CustomFilterProgramType programType;
CustomFilterProgramMixSettings mixSettings;
CustomFilterMeshType meshType;
if (!decoder->decode(vertexShaderString))
return false;
if (!decoder->decode(fragmentShaderString))
return false;
if (!decoder->decodeEnum(programType))
return false;
if (!decoder->decodeEnum(mixSettings.blendMode))
return false;
if (!decoder->decodeEnum(mixSettings.compositeOperator))
return false;
if (!decoder->decodeEnum(meshType))
return false;
RefPtr<CustomFilterProgram> program = WebCustomFilterProgram::create(vertexShaderString, fragmentShaderString, programType, mixSettings, meshType);
uint32_t parametersSize;
if (!decoder->decodeUInt32(parametersSize))
return false;
CustomFilterParameterList parameters(parametersSize);
for (size_t i = 0; i < parametersSize; ++i) {
String name;
CustomFilterParameter::ParameterType parameterType;
if (!decoder->decode(name))
return false;
if (!decoder->decodeEnum(parameterType))
return false;
switch (parameterType) {
case CustomFilterParameter::ARRAY: {
RefPtr<CustomFilterArrayParameter> arrayParameter = CustomFilterArrayParameter::create(name);
uint32_t arrayParameterSize;
if (!decoder->decodeUInt32(arrayParameterSize))
return false;
double arrayParameterValue;
for (size_t j = 0; j < arrayParameterSize; ++j) {
if (!decoder->decode(arrayParameterValue))
return false;
arrayParameter->addValue(arrayParameterValue);
}
parameters[i] = arrayParameter.release();
break;
}
case CustomFilterParameter::NUMBER: {
RefPtr<CustomFilterNumberParameter> numberParameter = CustomFilterNumberParameter::create(name);
uint32_t numberParameterSize;
if (!decoder->decodeUInt32(numberParameterSize))
return false;
double numberParameterValue;
for (size_t j = 0; j < numberParameterSize; ++j) {
if (!decoder->decode(numberParameterValue))
return false;
numberParameter->addValue(numberParameterValue);
}
parameters[i] = numberParameter.release();
break;
}
case CustomFilterParameter::TRANSFORM: {
RefPtr<CustomFilterTransformParameter> transformParameter = CustomFilterTransformParameter::create(name);
TransformOperations operations;
if (!ArgumentCoder<TransformOperations>::decode(decoder, operations))
return false;
transformParameter->setOperations(operations);
parameters[i] = transformParameter.release();
break;
}
}
}
unsigned meshRows;
unsigned meshColumns;
CustomFilterMeshBoxType meshBoxType;
if (!decoder->decode(meshRows))
return false;
if (!decoder->decode(meshColumns))
return false;
if (!decoder->decodeEnum(meshBoxType))
return false;
filter = CustomFilterOperation::create(program, parameters, meshRows, meshColumns, meshBoxType, meshType);
break;
}
#endif
default:
break;
}
if (filter)
operations.append(filter);
}
return true;
}
PassRefPtr<FormData> FormDataList::createMultiPartFormData()
{
RefPtr<FormData> result = FormData::create();
appendKeyValuePairItemsTo(result.get(), m_encoding, true);
return result.release();
}
PassRefPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3D::Attributes attributes, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle)
{
RefPtr<GraphicsContext3D> context = adoptRef(new GraphicsContext3D(attributes, hostWindow, false));
return context.release();
}
ScriptPromise MediaKeySession::generateRequest(ScriptState* scriptState, const String& initDataTypeString, const DOMArrayPiece& initData)
{
WTF_LOG(Media, "MediaKeySession(%p)::generateRequest %s", this, initDataTypeString.ascii().data());
// From https://w3c.github.io/encrypted-media/#generateRequest:
// Generates a request based on the initData. When this method is invoked,
// the user agent must run the following steps:
// 1. If this object's uninitialized value is false, return a promise
// rejected with a new DOMException whose name is "InvalidStateError".
if (!m_isUninitialized)
return CreateRejectedPromiseAlreadyInitialized(scriptState);
// 2. Let this object's uninitialized be false.
m_isUninitialized = false;
// 3. If initDataType is an empty string, return a promise rejected with a
// new DOMException whose name is "InvalidAccessError".
if (initDataTypeString.isEmpty()) {
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(InvalidAccessError, "The initDataType parameter is empty."));
}
// 4. If initData is an empty array, return a promise rejected with a new
// DOMException whose name is"InvalidAccessError".
if (!initData.byteLength()) {
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(InvalidAccessError, "The initData parameter is empty."));
}
// 5. If the Key System implementation represented by this object's cdm
// implementation value does not support initDataType as an
// Initialization Data Type, return a promise rejected with a new
// DOMException whose name is NotSupportedError. String comparison
// is case-sensitive.
// (blink side doesn't know what the CDM supports, so the proper check
// will be done on the Chromium side. However, we can verify that
// |initDataType| is one of the registered values.)
WebEncryptedMediaInitDataType initDataType = EncryptedMediaUtils::convertToInitDataType(initDataTypeString);
if (initDataType == WebEncryptedMediaInitDataType::Unknown) {
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(NotSupportedError, "The initialization data type '" + initDataTypeString + "' is not supported."));
}
// 6. Let init data be a copy of the contents of the initData parameter.
RefPtr<DOMArrayBuffer> initDataBuffer = DOMArrayBuffer::create(initData.data(), initData.byteLength());
// 7. Let session type be this object's session type.
// (Done in constructor.)
// 8. Let promise be a new promise.
NewSessionResultPromise* result = new NewSessionResultPromise(scriptState, this);
ScriptPromise promise = result->promise();
// 9. Run the following steps asynchronously (documented in
// actionTimerFired())
m_pendingActions.append(PendingAction::CreatePendingGenerateRequest(result, initDataType, initDataBuffer.release()));
ASSERT(!m_actionTimer.isActive());
m_actionTimer.startOneShot(0, FROM_HERE);
// 10. Return promise.
return promise;
}
PassRefPtr<HTMLTextAreaElement> HTMLTextAreaElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
{
RefPtr<HTMLTextAreaElement> textArea = adoptRef(new HTMLTextAreaElement(tagName, document, form));
textArea->createShadowSubtree();
return textArea.release();
}
PassRefPtr<CSSStyleSheet> CSSStyleSheet::createInline(Node* ownerNode, const KURL& baseURL, const TextPosition& startPosition, const String& encoding)
{
CSSParserContext parserContext(ownerNode->document(), baseURL, encoding);
RefPtr<StyleSheetContents> sheet = StyleSheetContents::create(baseURL.string(), parserContext);
return adoptRef(new CSSStyleSheet(sheet.release(), ownerNode, true, startPosition));
}
void IDBObjectStoreBackendImpl::putInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBTransactionBackendInterface> transaction)
{
RefPtr<SerializedScriptValue> value = prpValue;
RefPtr<IDBKey> key = prpKey;
// FIXME: Support auto-increment.
if (!objectStore->m_keyPath.isNull()) {
if (key) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "A key was supplied for an objectStore that has a keyPath."));
return;
}
key = fetchKeyFromKeyPath(value.get(), objectStore->m_keyPath);
if (!key) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "The key could not be fetched from the keyPath."));
return;
}
} else if (!key) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::DATA_ERR, "No key supplied."));
return;
}
if (key->type() == IDBKey::NullType) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::DATA_ERR, "NULL key is not allowed."));
return;
}
Vector<RefPtr<IDBKey> > indexKeys;
for (IndexMap::iterator it = objectStore->m_indexes.begin(); it != objectStore->m_indexes.end(); ++it) {
RefPtr<IDBKey> key = fetchKeyFromKeyPath(value.get(), it->second->keyPath());
if (!key) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "The key could not be fetched from an index's keyPath."));
return;
}
if (key->type() == IDBKey::NullType) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::DATA_ERR, "One of the derived (from a keyPath) keys for an index is NULL."));
return;
}
if (!it->second->addingKeyAllowed(key.get())) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "One of the derived (from a keyPath) keys for an index does not satisfy its uniqueness requirements."));
return;
}
indexKeys.append(key.release());
}
SQLiteStatement getQuery(objectStore->sqliteDatabase(), "SELECT id FROM ObjectStoreData " + whereClause(key.get()));
bool ok = getQuery.prepare() == SQLResultOk;
ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?
bindWhereClause(getQuery, objectStore->id(), key.get());
bool isExistingValue = getQuery.step() == SQLResultRow;
if (addOnly && isExistingValue) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::CONSTRAINT_ERR, "Key already exists in the object store."));
return;
}
// Before this point, don't do any mutation. After this point, rollback the transaction in case of error.
int64_t dataRowId = isExistingValue ? getQuery.getColumnInt(0) : InvalidId;
if (!putObjectStoreData(objectStore->sqliteDatabase(), key.get(), value.get(), objectStore->id(), dataRowId)) {
// FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
transaction->abort();
return;
}
if (!deleteIndexData(objectStore->sqliteDatabase(), dataRowId)) {
// FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
transaction->abort();
return;
}
int i = 0;
for (IndexMap::iterator it = objectStore->m_indexes.begin(); it != objectStore->m_indexes.end(); ++it, ++i) {
if (!putIndexData(objectStore->sqliteDatabase(), indexKeys[i].get(), it->second->id(), dataRowId)) {
// FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
transaction->abort();
return;
}
}
callbacks->onSuccess(key.get());
}
PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult()
{
RefPtr<ShapeResult> result = ShapeResult::create(m_font,
m_normalizedBufferLength, m_textRun.direction());
HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
const FontDescription& fontDescription = m_font->getFontDescription();
const String& localeString = fontDescription.locale();
CString locale = localeString.latin1();
const hb_language_t language = hb_language_from_string(locale.data(), locale.length());
RunSegmenter::RunSegmenterRange segmentRange = {
0,
0,
USCRIPT_INVALID_CODE,
OrientationIterator::OrientationInvalid,
SmallCapsIterator::SmallCapsSameCase,
FontFallbackPriority::Invalid };
RunSegmenter runSegmenter(
m_normalizedBuffer.get(),
m_normalizedBufferLength,
m_font->getFontDescription().orientation(),
fontDescription.variant());
Vector<UChar32> fallbackCharsHint;
// TODO: Check whether this treatAsZerowidthspace from the previous script
// segmentation plays a role here, does the new scriptRuniterator handle that correctly?
while (runSegmenter.consume(&segmentRange)) {
RefPtr<FontFallbackIterator> fallbackIterator =
m_font->createFontFallbackIterator(
segmentRange.fontFallbackPriority);
appendToHolesQueue(HolesQueueNextFont, 0, 0);
appendToHolesQueue(HolesQueueRange, segmentRange.start, segmentRange.end - segmentRange.start);
const SimpleFontData* currentFont = nullptr;
RefPtr<UnicodeRangeSet> currentFontRangeSet;
bool fontCycleQueued = false;
while (m_holesQueue.size()) {
HolesQueueItem currentQueueItem = m_holesQueue.takeFirst();
if (currentQueueItem.m_action == HolesQueueNextFont) {
// For now, we're building a character list with which we probe
// for needed fonts depending on the declared unicode-range of a
// segmented CSS font. Alternatively, we can build a fake font
// for the shaper and check whether any glyphs were found, or
// define a new API on the shaper which will give us coverage
// information?
if (!collectFallbackHintChars(fallbackCharsHint, fallbackIterator->needsHintList())) {
// Give up shaping since we cannot retrieve a font fallback
// font without a hintlist.
m_holesQueue.clear();
break;
}
FontDataForRangeSet nextFontDataForRangeSet = fallbackIterator->next(fallbackCharsHint);
currentFont = nextFontDataForRangeSet.fontData().get();
currentFontRangeSet = nextFontDataForRangeSet.ranges();
if (!currentFont) {
ASSERT(!m_holesQueue.size());
break;
}
fontCycleQueued = false;
continue;
}
// TODO crbug.com/522964: Only use smallCapsFontData when the font does not support true smcp. The spec
// says: "To match the surrounding text, a font may provide alternate glyphs for caseless characters when
// these features are enabled but when a user agent simulates small capitals, it must not attempt to
// simulate alternates for codepoints which are considered caseless."
const SimpleFontData* smallcapsAdjustedFont = segmentRange.smallCapsBehavior == SmallCapsIterator::SmallCapsUppercaseNeeded
? currentFont->smallCapsFontData(fontDescription).get()
: currentFont;
// Compatibility with SimpleFontData approach of keeping a flag for overriding drawing direction.
// TODO: crbug.com/506224 This should go away in favor of storing that information elsewhere, for example in
// ShapeResult.
const SimpleFontData* directionAndSmallCapsAdjustedFont = fontDataAdjustedForOrientation(smallcapsAdjustedFont,
m_font->getFontDescription().orientation(),
segmentRange.renderOrientation);
if (!shapeRange(harfBuzzBuffer.get(),
currentQueueItem.m_startIndex,
currentQueueItem.m_numCharacters,
directionAndSmallCapsAdjustedFont,
currentFontRangeSet,
segmentRange.script,
language))
DLOG(ERROR) << "Shaping range failed.";
if (!extractShapeResults(harfBuzzBuffer.get(),
result.get(),
fontCycleQueued,
currentQueueItem,
directionAndSmallCapsAdjustedFont,
segmentRange.script,
!fallbackIterator->hasNext()))
DLOG(ERROR) << "Shape result extraction failed.";
hb_buffer_reset(harfBuzzBuffer.get());
}
}
return result.release();
}
PassRefPtr<CSSValue> CSSParserValue::createCSSValue()
{
RefPtr<CSSValue> parsedValue;
if (id)
return CSSPrimitiveValue::createIdentifier(id);
if (unit == CSSParserValue::Operator) {
RefPtr<CSSPrimitiveValue> primitiveValue = CSSPrimitiveValue::createParserOperator(iValue);
primitiveValue->setPrimitiveType(CSSPrimitiveValue::CSS_PARSER_OPERATOR);
return primitiveValue.release();
}
if (unit == CSSParserValue::Function)
return CSSFunctionValue::create(function);
if (unit == CSSParserValue::ValueList)
return CSSValueList::createFromParserValueList(*valueList);
if (unit >= CSSParserValue::Q_EMS)
return CSSPrimitiveValue::createAllowingMarginQuirk(fValue, CSSPrimitiveValue::CSS_EMS);
CSSPrimitiveValue::UnitTypes primitiveUnit = static_cast<CSSPrimitiveValue::UnitTypes>(unit);
switch (primitiveUnit) {
case CSSPrimitiveValue::CSS_IDENT:
case CSSPrimitiveValue::CSS_PROPERTY_ID:
case CSSPrimitiveValue::CSS_VALUE_ID:
return CSSPrimitiveValue::create(string, CSSPrimitiveValue::CSS_PARSER_IDENTIFIER);
case CSSPrimitiveValue::CSS_NUMBER:
return CSSPrimitiveValue::create(fValue, isInt ? CSSPrimitiveValue::CSS_PARSER_INTEGER : CSSPrimitiveValue::CSS_NUMBER);
case CSSPrimitiveValue::CSS_STRING:
case CSSPrimitiveValue::CSS_URI:
case CSSPrimitiveValue::CSS_PARSER_HEXCOLOR:
return CSSPrimitiveValue::create(string, primitiveUnit);
case CSSPrimitiveValue::CSS_PERCENTAGE:
case CSSPrimitiveValue::CSS_EMS:
case CSSPrimitiveValue::CSS_EXS:
case CSSPrimitiveValue::CSS_PX:
case CSSPrimitiveValue::CSS_CM:
case CSSPrimitiveValue::CSS_MM:
case CSSPrimitiveValue::CSS_IN:
case CSSPrimitiveValue::CSS_PT:
case CSSPrimitiveValue::CSS_PC:
case CSSPrimitiveValue::CSS_DEG:
case CSSPrimitiveValue::CSS_RAD:
case CSSPrimitiveValue::CSS_GRAD:
case CSSPrimitiveValue::CSS_MS:
case CSSPrimitiveValue::CSS_S:
case CSSPrimitiveValue::CSS_HZ:
case CSSPrimitiveValue::CSS_KHZ:
case CSSPrimitiveValue::CSS_VW:
case CSSPrimitiveValue::CSS_VH:
case CSSPrimitiveValue::CSS_VMIN:
case CSSPrimitiveValue::CSS_VMAX:
case CSSPrimitiveValue::CSS_TURN:
case CSSPrimitiveValue::CSS_REMS:
case CSSPrimitiveValue::CSS_CHS:
case CSSPrimitiveValue::CSS_FR:
return CSSPrimitiveValue::create(fValue, primitiveUnit);
case CSSPrimitiveValue::CSS_UNKNOWN:
case CSSPrimitiveValue::CSS_DIMENSION:
case CSSPrimitiveValue::CSS_ATTR:
case CSSPrimitiveValue::CSS_COUNTER:
case CSSPrimitiveValue::CSS_RECT:
case CSSPrimitiveValue::CSS_RGBCOLOR:
case CSSPrimitiveValue::CSS_DPPX:
case CSSPrimitiveValue::CSS_DPI:
case CSSPrimitiveValue::CSS_DPCM:
case CSSPrimitiveValue::CSS_PAIR:
#if ENABLE(DASHBOARD_SUPPORT)
case CSSPrimitiveValue::CSS_DASHBOARD_REGION:
#endif
case CSSPrimitiveValue::CSS_UNICODE_RANGE:
case CSSPrimitiveValue::CSS_PARSER_OPERATOR:
case CSSPrimitiveValue::CSS_PARSER_INTEGER:
case CSSPrimitiveValue::CSS_PARSER_IDENTIFIER:
case CSSPrimitiveValue::CSS_COUNTER_NAME:
case CSSPrimitiveValue::CSS_SHAPE:
case CSSPrimitiveValue::CSS_QUAD:
#if ENABLE(CSS_SCROLL_SNAP)
case CSSPrimitiveValue::CSS_LENGTH_REPEAT:
#endif
case CSSPrimitiveValue::CSS_CALC:
case CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_NUMBER:
case CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_LENGTH:
return 0;
}
ASSERT_NOT_REACHED();
return 0;
}
PassRefPtr<MediaControlRootElementChromium> MediaControlRootElementChromium::create(Document* document)
{
if (!document->page())
return 0;
RefPtr<MediaControlRootElementChromium> controls = adoptRef(new MediaControlRootElementChromium(document));
// Create an enclosing element for the panel so we can visually offset the controls correctly.
RefPtr<MediaControlChromiumEnclosureElement> enclosure = MediaControlChromiumEnclosureElement::create(document);
RefPtr<MediaControlPanelElement> panel = MediaControlPanelElement::create(document);
ExceptionCode ec;
RefPtr<MediaControlPlayButtonElement> playButton = MediaControlPlayButtonElement::create(document);
controls->m_playButton = playButton.get();
panel->appendChild(playButton.release(), ec, true);
if (ec)
return 0;
RefPtr<MediaControlTimelineElement> timeline = MediaControlTimelineElement::create(document, controls.get());
controls->m_timeline = timeline.get();
panel->appendChild(timeline.release(), ec, true);
if (ec)
return 0;
RefPtr<MediaControlCurrentTimeDisplayElement> currentTimeDisplay = MediaControlCurrentTimeDisplayElement::create(document);
controls->m_currentTimeDisplay = currentTimeDisplay.get();
controls->m_currentTimeDisplay->hide();
panel->appendChild(currentTimeDisplay.release(), ec, true);
if (ec)
return 0;
RefPtr<MediaControlTimeRemainingDisplayElement> durationDisplay = MediaControlTimeRemainingDisplayElement::create(document);
controls->m_durationDisplay = durationDisplay.get();
panel->appendChild(durationDisplay.release(), ec, true);
if (ec)
return 0;
RefPtr<MediaControlPanelMuteButtonElement> panelMuteButton = MediaControlPanelMuteButtonElement::create(document, controls.get());
controls->m_panelMuteButton = panelMuteButton.get();
panel->appendChild(panelMuteButton.release(), ec, true);
if (ec)
return 0;
RefPtr<MediaControlVolumeSliderElement> slider = MediaControlVolumeSliderElement::create(document);
controls->m_volumeSlider = slider.get();
controls->m_volumeSlider->setClearMutedOnUserInteraction(true);
panel->appendChild(slider.release(), ec, true);
if (ec)
return 0;
RefPtr<MediaControlFullscreenButtonElement> fullscreenButton = MediaControlFullscreenButtonElement::create(document, controls.get());
controls->m_fullscreenButton = fullscreenButton.get();
panel->appendChild(fullscreenButton.release(), ec, true);
if (ec)
return 0;
controls->m_panel = panel.get();
enclosure->appendChild(panel.release(), ec, true);
if (ec)
return 0;
controls->m_enclosure = enclosure.get();
controls->appendChild(enclosure.release(), ec, true);
if (ec)
return 0;
return controls.release();
}
PassRefPtr<LayerTreeHostGtk> LayerTreeHostGtk::create(WebPage* webPage)
{
RefPtr<LayerTreeHostGtk> host = adoptRef(new LayerTreeHostGtk(webPage));
host->initialize();
return host.release();
}
void WebURLResponse::setLoadTiming(const WebURLLoadTiming& timing)
{
RefPtr<ResourceLoadTiming> loadTiming = PassRefPtr<ResourceLoadTiming>(timing);
m_private->m_resourceResponse->setResourceLoadTiming(loadTiming.release());
}
PassRefPtr<IDBRequest> IDBObjectStore::put(IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBAny> source, ScriptState* state, ScriptValue& value, PassRefPtr<IDBKey> prpKey, ExceptionCode& ec)
{
RefPtr<IDBKey> key = prpKey;
if (isDeleted()) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
if (m_transaction->isReadOnly()) {
ec = IDBDatabaseException::ReadOnlyError;
return 0;
}
// FIXME: Expose the JS engine exception state through ScriptState.
bool didThrow = false;
RefPtr<SerializedScriptValue> serializedValue = value.serialize(state, 0, 0, didThrow);
if (didThrow) {
// Setting an explicit ExceptionCode here would defer handling the already thrown exception.
return 0;
}
if (serializedValue->blobURLs().size() > 0) {
// FIXME: Add Blob/File/FileList support
ec = IDBDatabaseException::DataCloneError;
return 0;
}
const IDBKeyPath& keyPath = m_metadata.keyPath;
const bool usesInLineKeys = !keyPath.isNull();
const bool hasKeyGenerator = autoIncrement();
ScriptExecutionContext* context = scriptExecutionContextFromScriptState(state);
DOMRequestState requestState(context);
if (putMode != IDBDatabaseBackendInterface::CursorUpdate && usesInLineKeys && key) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (!usesInLineKeys && !hasKeyGenerator && !key) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (usesInLineKeys) {
RefPtr<IDBKey> keyPathKey = createIDBKeyFromScriptValueAndKeyPath(&requestState, value, keyPath);
if (keyPathKey && !keyPathKey->isValid()) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (!hasKeyGenerator && !keyPathKey) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (hasKeyGenerator && !keyPathKey) {
if (!canInjectIDBKeyIntoScriptValue(&requestState, value, keyPath)) {
ec = IDBDatabaseException::DataError;
return 0;
}
}
if (keyPathKey)
key = keyPathKey;
}
if (key && !key->isValid()) {
ec = IDBDatabaseException::DataError;
return 0;
}
Vector<int64_t> indexIds;
Vector<IndexKeys> indexKeys;
for (IDBObjectStoreMetadata::IndexMap::const_iterator it = m_metadata.indexes.begin(); it != m_metadata.indexes.end(); ++it) {
IndexKeys keys;
generateIndexKeysForValue(&requestState, it->value, value, &keys);
indexIds.append(it->key);
indexKeys.append(keys);
}
RefPtr<IDBRequest> request = IDBRequest::create(context, source, m_transaction.get());
Vector<uint8_t> valueBytes = serializedValue->toWireBytes();
// This is a hack to account for disagreements about whether SerializedScriptValue should deal in Vector<uint8_t> or Vector<char>.
// See https://lists.webkit.org/pipermail/webkit-dev/2013-February/023682.html
Vector<char>* valueBytesSigned = reinterpret_cast<Vector<char>*>(&valueBytes);
RefPtr<SharedBuffer> valueBuffer = SharedBuffer::adoptVector(*valueBytesSigned);
backendDB()->put(m_transaction->id(), id(), valueBuffer, key.release(), static_cast<IDBDatabaseBackendInterface::PutMode>(putMode), request, indexIds, indexKeys);
return request.release();
}
PassRefPtr<FormData> FormDataList::createFormData(FormData::EncodingType encodingType)
{
RefPtr<FormData> result = FormData::create();
appendKeyValuePairItemsTo(result.get(), m_encoding, false, encodingType);
return result.release();
}
PassRefPtr<HistoryItem> HistoryItem::decodeBackForwardTree(const String& topURLString, const String& topTitle, const String& topOriginalURLString, Decoder& decoder)
{
// Since the data stream is not trusted, the decode has to be non-recursive.
// We don't want bad data to cause a stack overflow.
uint32_t version;
if (!decoder.decodeUInt32(version))
return 0;
if (version != backForwardTreeEncodingVersion)
return 0;
String urlString = topURLString;
String title = topTitle;
String originalURLString = topOriginalURLString;
Vector<DecodeRecursionStackElement, 16> recursionStack;
recurse:
RefPtr<HistoryItem> node = create(urlString, title, 0);
node->setOriginalURLString(originalURLString);
title = String();
uint64_t size;
if (!decoder.decodeUInt64(size))
return 0;
size_t i;
RefPtr<HistoryItem> child;
for (i = 0; i < size; ++i) {
if (!decoder.decodeString(originalURLString))
return 0;
if (!decoder.decodeString(urlString))
return 0;
recursionStack.append(DecodeRecursionStackElement(node.release(), i, size));
goto recurse;
resume:
node->m_children.append(child.release());
}
if (!decoder.decodeInt64(node->m_documentSequenceNumber))
return 0;
if (!decoder.decodeUInt64(size))
return 0;
for (i = 0; i < size; ++i) {
String state;
if (!decoder.decodeString(state))
return 0;
node->m_documentState.append(state);
}
if (!decoder.decodeString(node->m_formContentType))
return 0;
bool hasFormData;
if (!decoder.decodeBool(hasFormData))
return 0;
if (hasFormData) {
node->m_formData = FormData::decodeForBackForward(decoder);
if (!node->m_formData)
return 0;
}
if (!decoder.decodeInt64(node->m_itemSequenceNumber))
return 0;
if (!decoder.decodeString(node->m_referrer))
return 0;
int32_t x;
if (!decoder.decodeInt32(x))
return 0;
int32_t y;
if (!decoder.decodeInt32(y))
return 0;
node->m_scrollPoint = IntPoint(x, y);
if (!decoder.decodeFloat(node->m_pageScaleFactor))
return 0;
bool hasStateObject;
if (!decoder.decodeBool(hasStateObject))
return 0;
if (hasStateObject) {
#if !USE(V8)
Vector<uint8_t> bytes;
if (!decoder.decodeBytes(bytes))
return 0;
node->m_stateObject = SerializedScriptValue::adopt(bytes);
#else
String string;
if (!decoder.decodeString(string))
return 0;
node->m_stateObject = SerializedScriptValue::createFromWire(string);
#endif
}
if (!decoder.decodeString(node->m_target))
return 0;
// Simulate recursion with our own stack.
if (!recursionStack.isEmpty()) {
DecodeRecursionStackElement& element = recursionStack.last();
child = node.release();
node = element.node.release();
i = element.i;
size = element.size;
recursionStack.removeLast();
goto resume;
}
return node.release();
}
void LayoutEditor::appendAnchorFor(JSONArray* anchors, const String& type, const String& propertyName)
{
RefPtr<JSONObject> description = createValueDescription(propertyName);
if (description)
anchors->pushObject(createAnchor(type, propertyName, description.release()));
}
PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const
{
RefPtr<CSSRule> rule;
StyleRuleBase* self = const_cast<StyleRuleBase*>(this);
switch (type()) {
case Style:
rule = CSSStyleRule::create(static_cast<StyleRule*>(self), parentSheet);
break;
case Page:
rule = CSSPageRule::create(static_cast<StyleRulePage*>(self), parentSheet);
break;
case FontFace:
rule = CSSFontFaceRule::create(static_cast<StyleRuleFontFace*>(self), parentSheet);
break;
case Media:
rule = CSSMediaRule::create(static_cast<StyleRuleMedia*>(self), parentSheet);
break;
#if ENABLE(CSS3_CONDITIONAL_RULES)
case Supports:
rule = CSSSupportsRule::create(static_cast<StyleRuleSupports*>(self), parentSheet);
break;
#endif
#if ENABLE(CSS_REGIONS)
case Region:
rule = WebKitCSSRegionRule::create(static_cast<StyleRuleRegion*>(self), parentSheet);
break;
#endif
case Import:
rule = CSSImportRule::create(static_cast<StyleRuleImport*>(self), parentSheet);
break;
case Keyframes:
rule = WebKitCSSKeyframesRule::create(static_cast<StyleRuleKeyframes*>(self), parentSheet);
break;
#if ENABLE(CSS_DEVICE_ADAPTATION)
case Viewport:
rule = WebKitCSSViewportRule::create(static_cast<StyleRuleViewport*>(self), parentSheet);
break;
#endif
#if ENABLE(SHADOW_DOM)
case HostInternal:
rule = CSSHostRule::create(static_cast<StyleRuleHost*>(self), parentSheet);
break;
#endif
#if ENABLE(CSS_SHADERS)
case Filter:
rule = WebKitCSSFilterRule::create(static_cast<StyleRuleFilter*>(self), parentSheet);
break;
#endif
case Unknown:
case Charset:
case Keyframe:
#if !ENABLE(CSS_REGIONS)
case Region:
#endif
ASSERT_NOT_REACHED();
return 0;
}
if (parentRule)
rule->setParentRule(parentRule);
return rule.release();
}
void PeerConnection00::didRemoveRemoteStream(MediaStreamDescriptor* streamDescriptor)
{
ASSERT(scriptExecutionContext()->isContextThread());
ASSERT(streamDescriptor->owner());
RefPtr<MediaStream> stream = static_cast<MediaStream*>(streamDescriptor->owner());
stream->streamEnded();
if (m_readyState == CLOSED)
return;
ASSERT(m_remoteStreams->contains(stream.get()));
m_remoteStreams->remove(stream.get());
dispatchEvent(MediaStreamEvent::create(eventNames().removestreamEvent, false, false, stream.release()));
}
void RenderObjectChildList::updateBeforeAfterContent(RenderObject* owner, PseudoId type, const RenderObject* styledObject)
{
// Double check that the document did in fact use generated content rules. Otherwise we should not have been called.
ASSERT(owner->document()->usesBeforeAfterRules());
// In CSS2, before/after pseudo-content cannot nest. Check this first.
if (owner->style()->styleType() == BEFORE || owner->style()->styleType() == AFTER)
return;
if (!styledObject)
styledObject = owner;
RenderStyle* pseudoElementStyle = styledObject->getCachedPseudoStyle(type);
RenderObject* child;
switch (type) {
case BEFORE:
child = beforePseudoElementRenderer(owner);
break;
case AFTER:
child = afterPseudoElementRenderer(owner);
break;
default:
ASSERT_NOT_REACHED();
return;
}
// Whether or not we currently have generated content attached.
bool oldContentPresent = child;
// Whether or not we now want generated content.
bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;
// For <q><p/></q>, if this object is the inline continuation of the <q>, we only want to generate
// :after content and not :before content.
if (newContentWanted && type == BEFORE && owner->isElementContinuation())
newContentWanted = false;
// Similarly, if we're the beginning of a <q>, and there's an inline continuation for our object,
// then we don't generate the :after content.
if (newContentWanted && type == AFTER && owner->virtualContinuation())
newContentWanted = false;
// If we don't want generated content any longer, or if we have generated content, but it's no longer
// identical to the new content data we want to build render objects for, then we nuke all
// of the old generated content.
if (oldContentPresent && (!newContentWanted || Node::diff(child->style(), pseudoElementStyle) == Node::Detach)) {
// Nuke the child.
if (child->style()->styleType() == type) {
oldContentPresent = false;
child->destroy();
child = (type == BEFORE) ? owner->virtualChildren()->firstChild() : owner->virtualChildren()->lastChild();
}
}
// If we have no pseudo-element style or if the pseudo-element style's display type is NONE, then we
// have no generated content and can now return.
if (!newContentWanted)
return;
if (owner->isRenderInline() && !pseudoElementStyle->isDisplayInlineType() && !pseudoElementStyle->isFloating() &&
!(pseudoElementStyle->position() == AbsolutePosition || pseudoElementStyle->position() == FixedPosition))
// According to the CSS2 spec (the end of section 12.1), the only allowed
// display values for the pseudo style are NONE and INLINE for inline flows.
// FIXME: CSS2.1 lifted this restriction, but block display types will crash.
// For now we at least relax the restriction to allow all inline types like inline-block
// and inline-table.
pseudoElementStyle->setDisplay(INLINE);
if (oldContentPresent) {
if (child && child->style()->styleType() == type) {
// We have generated content present still. We want to walk this content and update our
// style information with the new pseudo-element style.
child->setStyle(pseudoElementStyle);
RenderObject* beforeAfterParent = findBeforeAfterParent(child);
if (!beforeAfterParent)
return;
// When beforeAfterParent is not equal to child (e.g. in tables),
// we need to create new styles inheriting from pseudoElementStyle
// on all the intermediate parents (leaving their display same).
if (beforeAfterParent != child) {
RenderObject* curr = beforeAfterParent;
while (curr && curr != child) {
ASSERT(curr->isAnonymous());
RefPtr<RenderStyle> newStyle = RenderStyle::create();
newStyle->inheritFrom(pseudoElementStyle);
newStyle->setDisplay(curr->style()->display());
newStyle->setStyleType(curr->style()->styleType());
curr->setStyle(newStyle);
curr = curr->parent();
}
}
// Note that if we ever support additional types of generated content (which should be way off
// in the future), this code will need to be patched.
for (RenderObject* genChild = beforeAfterParent->firstChild(); genChild; genChild = genChild->nextSibling()) {
if (genChild->isText())
// Generated text content is a child whose style also needs to be set to the pseudo-element style.
genChild->setStyle(pseudoElementStyle);
else if (genChild->isImage()) {
// Images get an empty style that inherits from the pseudo.
RefPtr<RenderStyle> style = RenderStyle::create();
style->inheritFrom(pseudoElementStyle);
genChild->setStyle(style.release());
} else {
// RenderListItem may insert a list marker here. We do not need to care about this case.
// Otherwise, genChild must be a first-letter container. updateFirstLetter() will take care of it.
ASSERT(genChild->isListMarker() || genChild->style()->styleType() == FIRST_LETTER);
}
}
}
return; // We've updated the generated content. That's all we needed to do.
}
RenderObject* insertBefore = (type == BEFORE) ? owner->virtualChildren()->firstChild() : 0;
if (insertBefore && insertBefore->isAnonymousBlock() && insertBefore->childrenInline() && !insertBefore->isEmpty()) {
// We are going to add the "before" element. We have to check whether the "insertBefore" element
// is an anonymous block with inline children. If it is, then we should insert the "before" element
// before the first inline child of the anonymous block, otherwise we will end up with the "before"
// element in a different block. We do this only when the anonymous block has children, otherwise
// we end up with the before element in a wrong block.
insertBefore = insertBefore->firstChild();
}
// Generated content consists of a single container that houses multiple children (specified
// by the content property). This generated content container gets the pseudo-element style set on it.
RenderObject* generatedContentContainer = 0;
// Walk our list of generated content and create render objects for each.
for (const ContentData* content = pseudoElementStyle->contentData(); content; content = content->next()) {
RenderObject* renderer = 0;
switch (content->type()) {
case CONTENT_NONE:
break;
case CONTENT_TEXT:
renderer = new (owner->renderArena()) RenderTextFragment(owner->document() /* anonymous object */, static_cast<const TextContentData*>(content)->text().impl());
renderer->setStyle(pseudoElementStyle);
break;
case CONTENT_OBJECT: {
RenderImage* image = new (owner->renderArena()) RenderImage(owner->document()); // anonymous object
RefPtr<RenderStyle> style = RenderStyle::create();
style->inheritFrom(pseudoElementStyle);
image->setStyle(style.release());
if (const StyleImage* styleImage = static_cast<const ImageContentData*>(content)->image())
image->setImageResource(RenderImageResourceStyleImage::create(const_cast<StyleImage*>(styleImage)));
else
image->setImageResource(RenderImageResource::create());
renderer = image;
break;
}
case CONTENT_COUNTER:
renderer = new (owner->renderArena()) RenderCounter(owner->document(), *static_cast<const CounterContentData*>(content)->counter());
renderer->setStyle(pseudoElementStyle);
break;
case CONTENT_QUOTE:
renderer = new (owner->renderArena()) RenderQuote(owner->document(), static_cast<const QuoteContentData*>(content)->quote());
renderer->setStyle(pseudoElementStyle);
break;
}
if (renderer) {
if (!generatedContentContainer) {
// Make a generated box that might be any display type now that we are able to drill down into children
// to find the original content properly.
generatedContentContainer = RenderObject::createObject(owner->document(), pseudoElementStyle);
ASSERT(styledObject->node()); // The styled object cannot be anonymous or else it could not have ':before' or ':after' pseudo elements.
generatedContentContainer->setNode(styledObject->node()); // This allows access to the generatingNode.
generatedContentContainer->setStyle(pseudoElementStyle);
if (!owner->isChildAllowed(generatedContentContainer, pseudoElementStyle)) {
// The generated content container is not allowed here -> abort.
generatedContentContainer->destroy();
renderer->destroy();
return;
}
owner->addChild(generatedContentContainer, insertBefore);
}
if (generatedContentContainer->isChildAllowed(renderer, pseudoElementStyle))
generatedContentContainer->addChild(renderer);
else
renderer->destroy();
}
}
}
PassRefPtr<File> File::createWithRelativePath(const String& path, const String& relativePath)
{
RefPtr<File> file = adoptRef(new File(path));
file->m_relativePath = relativePath;
return file.release();
}
PassRefPtr<HTMLAppletElement> HTMLAppletElement::create(Document& document, bool createdByParser)
{
RefPtr<HTMLAppletElement> element = adoptRef(new HTMLAppletElement(document, createdByParser));
element->ensureUserAgentShadowRoot();
return element.release();
}
PassRefPtr<SecurityOrigin> SecurityOrigin::createUnique()
{
RefPtr<SecurityOrigin> origin = adoptRef(new SecurityOrigin());
ASSERT(origin->isUnique());
return origin.release();
}
v8::Handle<v8::Value> V8CInterface::constructorCustom(const v8::Arguments& args)
{
RefPtr<CInterface> cInterface = CInterface::create();
V8DOMWrapper::associateObjectWithWrapper(cInterface.release(), &info, args.Holder(), args.GetIsolate(), WrapperConfiguration::Dependent);
return args.Holder();;
}
WKImageRef WKPageCreateSnapshotOfVisibleContent(WKPageRef page)
{
RefPtr<WebImage> webImage = toImpl(page)->createSnapshotOfVisibleContent();
return toAPI(webImage.release().leakRef());
}
WKBundleNodeHandleRef WKBundleNavigationActionCopyFormElement(WKBundleNavigationActionRef navigationActionRef)
{
RefPtr<InjectedBundleNodeHandle> formElement = toImpl(navigationActionRef)->formElement();
return toAPI(formElement.release().leakRef());
}
