static ImageResourceContent* cachedImageForCSSValue(CSSValue* value,
const Document& document) {
if (!value)
return nullptr;
if (value->isImageValue()) {
StyleImage* styleImageResource =
toCSSImageValue(value)->cacheImage(document);
if (!styleImageResource)
return nullptr;
return styleImageResource->cachedImage();
}
if (value->isImageGeneratorValue()) {
toCSSImageGeneratorValue(value)->loadSubimages(document);
// FIXME: Handle CSSImageGeneratorValue (and thus cross-fades with gradients
// and canvas).
return nullptr;
}
ASSERT_NOT_REACHED();
return nullptr;
}
CachedImage* CSSImageGeneratorValue::cachedImageForCSSValue(CSSValue* value, CachedResourceLoader* cachedResourceLoader)
{
if (!value)
return nullptr;
if (value->isImageValue()) {
StyleCachedImage* styleCachedImage = toCSSImageValue(value)->cachedImage(cachedResourceLoader);
if (!styleCachedImage)
return nullptr;
return styleCachedImage->cachedImage();
}
if (value->isImageGeneratorValue()) {
toCSSImageGeneratorValue(value)->loadSubimages(cachedResourceLoader);
// FIXME: Handle CSSImageGeneratorValue (and thus cross-fades with gradients and canvas).
return nullptr;
}
if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone)
return nullptr;
ASSERT_NOT_REACHED();
return nullptr;
}
static bool subimageIsPending(CSSValue* value) {
if (value->isImageValue())
return toCSSImageValue(value)->isCachePending();
if (value->isImageGeneratorValue())
return toCSSImageGeneratorValue(value)->isPending();
ASSERT_NOT_REACHED();
return false;
}
static bool subimageKnownToBeOpaque(CSSValue* value,
const LayoutObject& layoutObject) {
if (value->isImageValue())
return toCSSImageValue(value)->knownToBeOpaque(layoutObject);
if (value->isImageGeneratorValue())
return toCSSImageGeneratorValue(value)->knownToBeOpaque(layoutObject);
ASSERT_NOT_REACHED();
return false;
}
static bool subimageKnownToBeOpaque(CSSValue* value, const RenderObject* renderer)
{
if (value->isImageValue())
return toCSSImageValue(value)->knownToBeOpaque(renderer);
if (value->isImageGeneratorValue())
return toCSSImageGeneratorValue(value)->knownToBeOpaque(renderer);
ASSERT_NOT_REACHED();
return false;
}
static bool subimageKnownToBeOpaque(CSSValue& value, const RenderElement* renderer)
{
if (value.isImageValue())
return toCSSImageValue(value).knownToBeOpaque(renderer);
if (value.isImageGeneratorValue())
return toCSSImageGeneratorValue(value).knownToBeOpaque(renderer);
ASSERT_NOT_REACHED();
return false;
}
bool CSSImageGeneratorValue::subimageIsPending(CSSValue* value)
{
if (value->isImageValue())
return toCSSImageValue(value)->cachedOrPendingImage()->isPendingImage();
if (value->isImageGeneratorValue())
return toCSSImageGeneratorValue(value)->isPending();
if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone)
return false;
ASSERT_NOT_REACHED();
return false;
}
PassRefPtrWillBeRawPtr<StyleImage> ElementStyleResources::styleImage(CSSPropertyID property, const CSSValue& value)
{
if (value.isImageValue())
return cachedOrPendingFromValue(property, toCSSImageValue(value));
if (value.isImageGeneratorValue())
return generatedOrPendingFromValue(property, toCSSImageGeneratorValue(value));
if (value.isImageSetValue())
return setOrPendingFromValue(property, toCSSImageSetValue(value));
if (value.isCursorImageValue())
return cursorOrPendingFromValue(property, toCSSCursorImageValue(value));
return nullptr;
}
PassRefPtr<StyleImage> ElementStyleResources::styleImage(Document& document, const TextLinkColors& textLinkColors, Color currentColor, CSSPropertyID property, CSSValue* value)
{
if (value->isImageValue())
return cachedOrPendingFromValue(document, property, toCSSImageValue(value));
if (value->isImageGeneratorValue()) {
if (value->isGradientValue())
return generatedOrPendingFromValue(property, toCSSGradientValue(value)->gradientWithStylesResolved(textLinkColors, currentColor).get());
return generatedOrPendingFromValue(property, toCSSImageGeneratorValue(value));
}
if (value->isImageSetValue())
return setOrPendingFromValue(property, toCSSImageSetValue(value));
return nullptr;
}
PassRefPtrWillBeRawPtr<StyleImage> ElementStyleResources::styleImage(Document& document, const TextLinkColors& textLinkColors, Color currentColor, CSSPropertyID property, CSSValue* value)
{
if (value->isImageValue())
return cachedOrPendingFromValue(document, property, toCSSImageValue(value));
if (value->isImageGeneratorValue())
return generatedOrPendingFromValue(property, toCSSImageGeneratorValue(value));
if (value->isImageSetValue())
return setOrPendingFromValue(property, toCSSImageSetValue(value));
if (value->isCursorImageValue())
return cursorOrPendingFromValue(property, toCSSCursorImageValue(value));
return nullptr;
}
static ImageResource* cachedImageForCSSValue(CSSValue* value, ResourceFetcher* fetcher)
{
if (!value)
return 0;
if (value->isImageValue()) {
StyleFetchedImage* styleImageResource = toCSSImageValue(value)->cachedImage(fetcher);
if (!styleImageResource)
return 0;
return styleImageResource->cachedImage();
}
if (value->isImageGeneratorValue()) {
toCSSImageGeneratorValue(value)->loadSubimages(fetcher);
// FIXME: Handle CSSImageGeneratorValue (and thus cross-fades with gradients and canvas).
return 0;
}
ASSERT_NOT_REACHED();
return 0;
}
void StyleBuilderFunctions::applyValueCSSPropertyContent(StyleResolverState& state, CSSValue* value)
{
// list of string, uri, counter, attr, i
bool didSet = false;
for (auto& item : toCSSValueList(*value)) {
if (item->isImageGeneratorValue()) {
state.style()->setContent(StyleGeneratedImage::create(toCSSImageGeneratorValue(item.get())), didSet);
didSet = true;
} else if (item->isImageSetValue()) {
state.style()->setContent(state.elementStyleResources().setOrPendingFromValue(CSSPropertyContent, toCSSImageSetValue(item.get())), didSet);
didSet = true;
}
if (item->isImageValue()) {
state.style()->setContent(state.elementStyleResources().cachedOrPendingFromValue(state.document(), CSSPropertyContent, toCSSImageValue(item.get())), didSet);
didSet = true;
continue;
}
if (item->isCounterValue()) {
CSSCounterValue* counterValue = toCSSCounterValue(item.get());
EListStyleType listStyleType = NoneListStyle;
CSSValueID listStyleIdent = counterValue->listStyle();
if (listStyleIdent != CSSValueNone)
listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
OwnPtr<CounterContent> counter = adoptPtr(new CounterContent(AtomicString(counterValue->identifier()), listStyleType, AtomicString(counterValue->separator())));
state.style()->setContent(counter.release(), didSet);
didSet = true;
}
if (item->isFunctionValue()) {
CSSFunctionValue* functionValue = toCSSFunctionValue(item.get());
ASSERT(functionValue->functionType() == CSSValueAttr);
// FIXME: Can a namespace be specified for an attr(foo)?
if (state.style()->styleType() == NOPSEUDO)
state.style()->setUnique();
else
state.parentStyle()->setUnique();
QualifiedName attr(nullAtom, AtomicString(toCSSPrimitiveValue(functionValue->item(0))->getStringValue()), nullAtom);
const AtomicString& value = state.element()->getAttribute(attr);
state.style()->setContent(value.isNull() ? emptyString() : value.string(), didSet);
didSet = true;
}
if (!item->isPrimitiveValue())
continue;
CSSPrimitiveValue* contentValue = toCSSPrimitiveValue(item.get());
if (contentValue->isString()) {
state.style()->setContent(contentValue->getStringValue().impl(), didSet);
didSet = true;
} else {
switch (contentValue->getValueID()) {
case CSSValueOpenQuote:
state.style()->setContent(OPEN_QUOTE, didSet);
didSet = true;
break;
case CSSValueCloseQuote:
state.style()->setContent(CLOSE_QUOTE, didSet);
didSet = true;
break;
case CSSValueNoOpenQuote:
state.style()->setContent(NO_OPEN_QUOTE, didSet);
didSet = true;
break;
case CSSValueNoCloseQuote:
state.style()->setContent(NO_CLOSE_QUOTE, didSet);
didSet = true;
break;
default:
// normal and none do not have any effect.
{ }
}
}
}
if (!didSet)
state.style()->clearContent();
}
